cairo: Clean up dispose implementations

cairo/FontFace.cs

@@ -50,24 +50,27 @@ namespace Cairo
 
 		~FontFace ()
 		{
-			// Since Cairo is not thread safe, we can not unref the
-			// font_face here, the programmer must do this with Dispose
-
-			Console.Error.WriteLine ("Programmer forgot to call Dispose on the FontFace");
 			Dispose (false);
 		}
 
 		public void Dispose ()
 		{
 			Dispose (true);
+			GC.SuppressFinalize (this);
 		}
 
 		protected virtual void Dispose (bool disposing)
 		{
-			if (disposing)
+			if (handle == IntPtr.Zero)
+				return;
+
+			if (!disposing) {
+				Console.Error.WriteLine ("Cairo.FontFace: called from finalization thread, programmer is missing a call to Dispose");
+				return;
+			}
+
 			NativeMethods.cairo_font_face_destroy (handle);
 			handle = IntPtr.Zero;
-			GC.SuppressFinalize (this);
 		}
 		
 		// TODO: make non-public when all entry points are complete in binding

cairo/FontOptions.cs

@@ -33,7 +33,6 @@ namespace Cairo
 	public class FontOptions : IDisposable
 	{
 		IntPtr handle;
-		bool disposed;
 
 		public FontOptions ()
 		{
@@ -55,9 +54,10 @@ namespace Cairo
 			return new FontOptions (NativeMethods.cairo_font_options_copy (handle));
 		}
 
+		[Obsolete ("Use Dispose()")]
 		public void Destroy ()
 		{
-			NativeMethods.cairo_font_options_destroy (handle);
+			Dispose ();
 		}
 
 		public void Dispose ()
@@ -66,13 +66,18 @@ namespace Cairo
 			GC.SuppressFinalize (this);
 		}
 
-		private void Dispose (bool disposing)
+		protected virtual void Dispose (bool disposing)
 		{
-			if (!disposed) {
+			if (handle == IntPtr.Zero)
-				Destroy ();
+				return;
-				handle = IntPtr.Zero;
+
+			if (!disposing) {
+				Console.Error.WriteLine ("Cairo.FontOptions: called from finalization thread, programmer is missing a call to Dispose");
+				return;
 			}
-			disposed = true;
+
+			NativeMethods.cairo_font_options_destroy (handle);
+			handle = IntPtr.Zero;
 		}
 
 		public static bool operator == (FontOptions options, FontOptions other)

cairo/Pattern.cs

@@ -76,6 +76,7 @@ namespace Cairo {
 
 		~Pattern ()
 		{
+			Dispose (false);
 		}
 		
                 [Obsolete ("Use the SurfacePattern constructor")]
@@ -92,26 +93,32 @@ namespace Cairo {
 		public void Dispose ()
 		{
 			Dispose (true);
+			GC.SuppressFinalize (this);
 		}
 
 		protected virtual void Dispose (bool disposing)
 		{
-			if (disposing)
+			if (!disposing) {
-				Destroy ();
+				Console.Error.WriteLine ("Cairo.Pattern: called from finalization thread, programmer is missing a call to Dispose");
-			GC.SuppressFinalize (this);
+				return;
 			}
 
-                public void Destroy ()
+			if (pattern == IntPtr.Zero)
-                {
+				return;
-			if (pattern != IntPtr.Zero){
+
 			NativeMethods.cairo_pattern_destroy (pattern);
 			pattern = IntPtr.Zero;
-			}
 			lock (patterns){
 				patterns.Remove (this);
 			}
 		}
 
+		[Obsolete ("Use Dispose()")]
+                public void Destroy ()
+                {
+			Dispose ();
+                }
+		
 		public Extend Extend {
 			get { return NativeMethods.cairo_pattern_get_extend (pattern); }
 			set { NativeMethods.cairo_pattern_set_extend (pattern, value); }

cairo/ScaledFont.cs

@@ -99,11 +99,17 @@ namespace Cairo {
 
 		protected virtual void Dispose (bool disposing)
 		{
-			if (disposing) {
+			if (handle == IntPtr.Zero)
+				return;
+
+			if (!disposing) {
+				Console.Error.WriteLine ("Cairo.ScaledFont: called from finalization thread, programmer is missing a call to Dispose");
+				return;
+			}
+
 			NativeMethods.cairo_scaled_font_destroy (handle);
 			handle = IntPtr.Zero;
 		}
-		}
 		
                 protected void Reference ()
                 {

cairo/Surface.cs

@@ -149,6 +149,10 @@ namespace Cairo {
 		{
 			if (surface == IntPtr.Zero)
 				return;
+			if (!disposing) {
+				Console.Error.WriteLine ("Cairo.Surface: called from finalization thread, programmer is missing a call to Dispose");
+				return;
+			}
 			
 			lock (surfaces.SyncRoot)
 				surfaces.Remove (surface);