Make a copy of the old ZipLib
[mono.git] / mcs / class / Mono.Cairo / Mono.Cairo / Surface.cs
index 96e3cb68b4b8d827b7b6849b0685101be75d1978..5ed1d081ac3e49ebca003e28310b624b2f1ce5fd 100644 (file)
 //
 
 using System;
-using System.Drawing;
-using System.Runtime.InteropServices;
 using System.Collections;
-using Cairo;
 
 namespace Cairo {
 
-       public class Surface : IDisposable 
+        public class ImageSurface : Surface
         {
-               static Hashtable surfaces = new Hashtable ();
+               public ImageSurface (Format format, int width, int height)
+               {
+                       surface = CairoAPI.cairo_image_surface_create (format, width, height);
+                       lock (surfaces.SyncRoot){
+                               surfaces [surface] = this;
+                       }
+               }
+
+               public ImageSurface (string data, Cairo.Format format, int width, int height, int stride)
+               {
+                       surface = CairoAPI.cairo_image_surface_create_for_data (data, format, width, height, stride);
+                       lock (surfaces.SyncRoot){
+                               surfaces [surface] = this;
+                       }
+               }
+               
+               public ImageSurface (string filename)
+               {
+                       surface = CairoAPI.cairo_image_surface_create_from_png (filename);
+                       lock (surfaces.SyncRoot){
+                               surfaces [surface] = this;
+                       }
+               }
+               
+               public int Width {
+                       get { return CairoAPI.cairo_image_surface_get_width (surface); }
+               }
+               
+               public int Height {
+                       get { return CairoAPI.cairo_image_surface_get_height (surface); }
+               }
+               
+       }
+
+       #if UNSTABLE
+       public class PdfSurface : Surface
+       {
+               public PdfSurface (string filename, double width, double height)
+               {
+                       surface = CairoAPI.cairo_pdf_surface_create (filename, width, height);
+                       lock (surfaces.SyncRoot){
+                               surfaces [surface] = this;
+                       }
+               }
+
+               public void SetDPI (double x_dpi, double y_dpi)
+               {
+                       CairoAPI.cairo_pdf_surface_set_dpi (surface, x_dpi, y_dpi);
+               }
+       }
+
+       public class PostscriptSurface : Surface
+       {
+               public PostscriptSurface (string filename, double width, double height)
+               {
+                       surface = CairoAPI.cairo_ps_surface_create (filename, width, height);
+                       lock (surfaces.SyncRoot){
+                               surfaces [surface] = this;
+                       }
+               }
+
+               public void SetDPI (double x_dpi, double y_dpi)
+               {
+                       CairoAPI.cairo_ps_surface_set_dpi (surface, x_dpi, y_dpi);
+               }
+       }
+       #endif
+
+       public class Win32Surface : Surface
+       {
+               public Win32Surface (IntPtr hdc)
+               {
+                       surface = CairoAPI.cairo_win32_surface_create (hdc);
+                       lock (surfaces.SyncRoot){
+                               surfaces [surface] = this;
+                       }
+               }
+       }
+
+       public class XlibSurface : Surface
+       {
+               public XlibSurface (IntPtr display, IntPtr drawable, IntPtr visual, int width, int height)
+               {
+                       surface = CairoAPI.cairo_xlib_surface_create (display, drawable, visual, width, height);
+                       lock (surfaces.SyncRoot){
+                               surfaces [surface] = this;
+                       }
+               }
+
+               /* FIXME: has the same parameters as above
+               public XlibSurface (IntPtr display, IntPtr bitmap, IntPtr screen, int width, int height)
+               {
+                       surface = CairoAPI.cairo_xlib_surface_create_for_bitmap (display, bitmap, screen, width, height);
+                       lock (surfaces.SyncRoot){
+                               surfaces [surface] = this;
+                       }
+               }
+               */
+
+               public void SetDrawable (IntPtr drawable, int width, int height)
+               {
+                       CairoAPI.cairo_xlib_surface_set_drawable (surface, drawable, width, height);
+               }
+
+               public void SetSize (int width, int height)
+               {
+                       CairoAPI.cairo_xlib_surface_set_size (surface, width, height);
+               }
+       }
+   
+       public class Surface : IDisposable 
+        {                                              
+               protected static Hashtable surfaces = new Hashtable ();
                 internal IntPtr surface = IntPtr.Zero;
 
+               protected Surface()
+               {
+                       Console.WriteLine (Environment.StackTrace);
+               }
+               
                 private Surface (IntPtr ptr, bool owns)
                 {
                         surface = ptr;
-                       lock (typeof (Surface)){
+                       lock (surfaces.SyncRoot){
                                surfaces [ptr] = this;
                        }
                        if (!owns)
@@ -57,24 +171,26 @@ namespace Cairo {
 
                static internal Surface LookupExternalSurface (IntPtr p)
                {
-                       lock (typeof (Surface)){
+                       lock (surfaces.SyncRoot){
                                object o = surfaces [p];
                                if (o == null){
                                        return new Surface (p, false);
                                }
                                return (Surface) o;
                        }
-               }
-
+               }               
+               
+               [Obsolete ("Use an ImageSurface constructor instead.")]
                 public static Cairo.Surface CreateForImage (
                         string data, Cairo.Format format, int width, int height, int stride)
                 {
-                        IntPtr p = CairoAPI.cairo_surface_create_for_image (
+                        IntPtr p = CairoAPI.cairo_image_surface_create_for_data (
                                 data, format, width, height, stride);
                         
                         return new Cairo.Surface (p, true);
                 }
 
+               [Obsolete ("Use an ImageSurface constructor instead.")]
                 public static Cairo.Surface CreateForImage (
                         Cairo.Format format, int width, int height)
                 {
@@ -85,21 +201,11 @@ namespace Cairo {
                 }
 
 
-                public static Cairo.Surface CreateSimilar (
-                        Cairo.Surface surface, Cairo.Format format, int width, int height)
+                public Cairo.Surface CreateSimilar (
+                        Cairo.Content content, int width, int height)
                 {
                         IntPtr p = CairoAPI.cairo_surface_create_similar (
-                                surface.Handle, format, width, height);
-
-                        return new Cairo.Surface (p, true);
-                }
-
-                public static Cairo.Surface CreateSimilarSolid (
-                        Cairo.Surface surface, Cairo.Format format,
-                        int width, int height, double red, double green, double blue, double alpha)
-                {
-                        IntPtr p = CairoAPI.cairo_surface_create_similar_solid (
-                                surface.Handle, format, width, height, red, green, blue, alpha);
+                                this.Handle, content, width, height);
 
                         return new Cairo.Surface (p, true);
                 }
@@ -111,7 +217,8 @@ namespace Cairo {
 
                public void Show (Graphics gr, int width, int height) 
                {
-                       CairoAPI.cairo_show_surface (gr.Handle, surface, width,  height);
+                       CairoAPI.cairo_set_source_surface (gr.Handle, surface, width, height);
+                       CairoAPI.cairo_paint (gr.Handle);
                }
 
                void IDisposable.Dispose ()
@@ -124,46 +231,50 @@ namespace Cairo {
                {
                        if (surface == (IntPtr) 0)
                                return;
-                       lock (typeof (Surface)){
+                       
+                       lock (surfaces.SyncRoot)
                                surfaces.Remove (surface);
-                       }
+
                        CairoAPI.cairo_surface_destroy (surface);
                        surface = (IntPtr) 0;
                }
                
+               public Cairo.Status Finish ()
+               {
+                       return CairoAPI.cairo_surface_finish (surface);
+               }
+               
                 public IntPtr Handle {
-                        get { return surface; }
-                }
-
-                public int Repeat {
-                        set {
-                                CairoAPI.cairo_surface_set_repeat (surface, value);
-                        } 
-                }
-
-                public Cairo.Matrix Matrix {
-                        set {
-                                CairoAPI.cairo_surface_set_matrix (surface, value.Pointer);
-                        }
-
                         get {
-                                IntPtr p = IntPtr.Zero;
-                                CairoAPI.cairo_surface_get_matrix (surface, out p);
-                                return new Cairo.Matrix (p);
-                        }
+                               return surface;
+                       }
                 }
 
-                public Cairo.Filter Filter {
-                        set {
-                                CairoAPI.cairo_surface_set_filter (surface, value);
-                        }
-                }
+               public PointD DeviceOffset {
+                       set {
+                               CairoAPI.cairo_surface_set_device_offset (surface, value.X, value.Y);
+                       }
+               }
+               
+               public void Destroy()
+               {
+                       CairoAPI.cairo_surface_destroy (surface);
+               }
 
+               public void WriteToPng (string filename)
+               {
+                       CairoAPI.cairo_surface_write_to_png (surface, filename);
+               }
+               
                 public IntPtr Pointer {
-                        get { return surface; }
+                        get {
+                               return surface;
+                       }
                 }
-
-
+               
+               public Status Status {
+                       get { return CairoAPI.cairo_surface_status (surface); }
+               }
 
         }
 }