cairo.Region to handle clipping

diff --git a/Crow.csproj b/Crow.csproj
index 3e8bcd553743293bc3f6f2fbb87b67a1d16be7a1..1c41900830e55d13733f2e2cb499d6493f5a6e17 100644 (file)
--- a/Crow.csproj
+++ b/Crow.csproj
@@ -42,7 +42,6 @@
     <Compile Include="src\Colors.cs" />
     <Compile Include="src\Point.cs" />
     <Compile Include="src\Rectangle.cs" />
-    <Compile Include="src\Rectangles.cs" />
     <Compile Include="src\Size.cs" />
     <Compile Include="src\GraphicObjects\GraphicObject.cs" />
     <Compile Include="src\GraphicObjects\Container.cs" />

diff --git a/src/GraphicObjects/GraphicObject.cs b/src/GraphicObjects/GraphicObject.cs
index 5de94f6092c44702042b3a2a01618d83676a77f4..e7c22d9ad8bf8b3273515126fd8973a79795b591 100644 (file)
--- a/src/GraphicObjects/GraphicObject.cs
+++ b/src/GraphicObjects/GraphicObject.cs
@@ -58,8 +58,7 @@ namespace Crow
                        }
                }
 
-               Rectangles clipping = new Rectangles();
-               public Rectangles Clipping { get { return clipping; }}
+               public Region Clipping = new Region();
 
                #region IValueChange implementation
                public event EventHandler<ValueChangeEventArgs> ValueChanged;
@@ -845,7 +844,7 @@ namespace Crow
                public virtual void RegisterClip(Rectangle clip){
                        Rectangle  r = clip + ClientRectangle.Position;
                        if (CacheEnabled && !IsDirty)
-                               Clipping.AddRectangle (r);
+                               Clipping.UnionRectangle (r);
                        if (Parent == null)
                                return;
                        GraphicObject p = Parent as GraphicObject;
@@ -1108,7 +1107,7 @@ namespace Crow
                        Rectangle rBack = new Rectangle (Slot.Size);
 
                        Background.SetAsSource (gr, rBack);
-                       CairoHelpers.CairoRectangle(gr,rBack,cornerRadius);
+                       CairoHelpers.CairoRectangle (gr, rBack, cornerRadius);
                        gr.Fill ();
                }
 
@@ -1144,8 +1143,8 @@ namespace Crow
                                ctx.SetSourceSurface (cache, rb.X, rb.Y);
                                ctx.Paint ();
                        }
-                       //Clipping.clearAndClip (ctx);
-                       Clipping.Reset();
+                       Clipping.Dispose ();
+                       Clipping = new Region ();
                }
                /// <summary> Chained painting routine on the parent context of the actual cached version
                /// of the widget </summary>

diff --git a/src/GraphicObjects/Group.cs b/src/GraphicObjects/Group.cs
index 0739d48054275815fcdf8cdacd50a72745b6a9cd..55c4fc8b38a821597b5f62e893292788f101065c 100644 (file)
--- a/src/GraphicObjects/Group.cs
+++ b/src/GraphicObjects/Group.cs
@@ -237,20 +237,28 @@ namespace Crow
                        using (ImageSurface cache = new ImageSurface (bmp, Format.Argb32, Slot.Width, Slot.Height, 4 * Slot.Width)) {
                                Context gr = new Context (cache);
 
-                               if (Clipping.count > 0) {
-                                       Clipping.clearAndClip (gr);
+                               if (!Clipping.IsEmpty) {
+                                       for (int i = 0; i < Clipping.NumRectangles; i++)
+                                               gr.Rectangle(Clipping.GetRectangle(i));
+                                       gr.ClipPreserve();
+                                       gr.Operator = Operator.Clear;
+                                       gr.Fill();
+                                       gr.Operator = Operator.Over;
+
                                        base.onDraw (gr);
 
-                                       //clip to client zone
-                                       CairoHelpers.CairoRectangle (gr, ClientRectangle, CornerRadius);
-                                       gr.Clip ();
+                                       if (ClipToClientRect) {
+                                               CairoHelpers.CairoRectangle (gr, ClientRectangle, CornerRadius);
+                                               gr.Clip ();
+                                       }
 
                                        lock (Children) {
                                                foreach (GraphicObject c in Children) {
                                                        if (!c.Visible)
                                                                continue;
-                                                       if (Clipping.intersect (c.Slot + ClientRectangle.Position))
-                                                               c.Paint (ref gr);
+                                                       if (Clipping.Contains (c.Slot + ClientRectangle.Position) == RegionOverlap.Out)
+                                                               continue;
+                                                       c.Paint (ref gr);
                                                }
                                        }
 
@@ -263,7 +271,8 @@ namespace Crow
                                ctx.SetSourceSurface (cache, rb.X, rb.Y);
                                ctx.Paint ();
                        }
-                       Clipping.Reset();
+                       Clipping.Dispose();
+                       Clipping = new Region ();
                }
                #endregion
 

diff --git a/src/GraphicObjects/PrivateContainer.cs b/src/GraphicObjects/PrivateContainer.cs
index 4076b5ec59a048662d57ed23510825978af783f8..73a971dbbe20cd5cef30dff0eb57d0a52b951b29 100644 (file)
--- a/src/GraphicObjects/PrivateContainer.cs
+++ b/src/GraphicObjects/PrivateContainer.cs
@@ -182,8 +182,13 @@ namespace Crow
                        using (ImageSurface cache = new ImageSurface (bmp, Format.Argb32, Slot.Width, Slot.Height, 4 * Slot.Width)) {
                                Context gr = new Context (cache);
 
-                               if (Clipping.count > 0) {
-                                       Clipping.clearAndClip (gr);
+                               if (!Clipping.IsEmpty) {
+                                       for (int i = 0; i < Clipping.NumRectangles; i++)
+                                               gr.Rectangle(Clipping.GetRectangle(i));
+                                       gr.ClipPreserve();
+                                       gr.Operator = Operator.Clear;
+                                       gr.Fill();
+                                       gr.Operator = Operator.Over;
 
                                        onDraw (gr);
                                }
@@ -193,7 +198,8 @@ namespace Crow
                                ctx.SetSourceSurface (cache, rb.X, rb.Y);
                                ctx.Paint ();
                        }
-                       Clipping.Reset();
+                       Clipping.Dispose();
+                       Clipping = new Region ();
                }
                #endregion
 

diff --git a/src/Interface.cs b/src/Interface.cs
index 7faace46c7389ce57f36c46f26f6ea4cd15a8c83..90a757c53c481beb830c0af96571093f5f4eb150 100644 (file)
--- a/src/Interface.cs
+++ b/src/Interface.cs
@@ -160,7 +160,7 @@ namespace Crow
                /// <summary>Client rectangle in the host context</summary>
                Rectangle clientRectangle;
                /// <summary>Clipping rectangles on the root context</summary>
-               Rectangles clipping = new Rectangles();
+               Region clipping = new Region();
                /// <summary>Main Cairo context</summary>
                Context ctx;
                /// <summary>Main Cairo surface</summary>
@@ -502,20 +502,24 @@ namespace Crow
                        #endif
                        using (surf = new ImageSurface (bmp, Format.Argb32, ClientRectangle.Width, ClientRectangle.Height, ClientRectangle.Width * 4)) {
                                using (ctx = new Context (surf)){
-                                       if (clipping.count > 0) {
-                                               //Link.draw (ctx);
-                                               clipping.clearAndClip(ctx);
+                                       if (!clipping.IsEmpty) {
+
+                                               for (int i = 0; i < clipping.NumRectangles; i++)
+                                                       ctx.Rectangle(clipping.GetRectangle(i));
+                                               ctx.ClipPreserve();
+                                               ctx.Operator = Operator.Clear;
+                                               ctx.Fill();
+                                               ctx.Operator = Operator.Over;
 
                                                for (int i = GraphicTree.Count -1; i >= 0 ; i--){
                                                        GraphicObject p = GraphicTree[i];
                                                        if (!p.Visible)
                                                                continue;
-                                                       if (!clipping.intersect (p.Slot))
+                                                       if (clipping.Contains (p.Slot) == RegionOverlap.Out)
                                                                continue;
-                                                       ctx.Save ();
 
+                                                       ctx.Save ();
                                                        p.Paint (ref ctx);
-
                                                        ctx.Restore ();
                                                }
 
@@ -524,11 +528,12 @@ namespace Crow
                                                #endif
                                                lock (RenderMutex) {
 //                                                     Array.Copy (bmp, dirtyBmp, bmp.Length);
+
                                                        IsDirty = true;
                                                        if (IsDirty)
-                                                               DirtyRect += clipping.Bounds;
+                                                               DirtyRect += clipping.Extents;
                                                        else
-                                                               DirtyRect = clipping.Bounds;
+                                                               DirtyRect = clipping.Extents;
 
                                                        DirtyRect.Left = Math.Max (0, DirtyRect.Left);
                                                        DirtyRect.Top = Math.Max (0, DirtyRect.Top);
@@ -548,7 +553,8 @@ namespace Crow
                                                        } else
                                                                IsDirty = false;
                                                }
-                                               clipping.Reset ();
+                                               clipping.Dispose ();
+                                               clipping = new Region ();
                                        }
                                        //surf.WriteToPng (@"/mnt/data/test.png");
                                }
@@ -664,7 +670,7 @@ namespace Crow
                                foreach (GraphicObject g in GraphicTree)
                                        g.RegisterForLayouting (LayoutingType.All);
 
-                               clipping.AddRectangle (clientRectangle);
+                               RegisterClip (clientRectangle);
                        }
                }
 
@@ -878,7 +884,7 @@ namespace Crow
 
                #region ILayoutable implementation
                public void RegisterClip(Rectangle r){
-                       clipping.AddRectangle (r);
+                       clipping.UnionRectangle (r);
                }
                public bool ArrangeChildren { get { return false; }}
                public int LayoutingTries {

diff --git a/src/Mono.Cairo/Context.cs b/src/Mono.Cairo/Context.cs
index 7ca0dee45dd5f5ee5ebb41c273fc1c3373d62297..3b731a98093bcc935d2d4e2c0a41b5805cba4d79 100644 (file)
--- a/src/Mono.Cairo/Context.cs
+++ b/src/Mono.Cairo/Context.cs
@@ -563,7 +563,14 @@ namespace Cairo {
                {
                        return NativeMethods.cairo_in_clip (handle, x, y);
                }
-
+               public RectangleList GetClipRectangles (){
+                       return (RectangleList)Marshal.PtrToStructure (NativeMethods.cairo_copy_clip_rectangle_list (handle), typeof(RectangleList));
+               }
+               public void ClipExtendRectangle (){
+                       double x1, y1, x2, y2;
+                       NativeMethods.cairo_clip_extents (handle, out x1, out y1, out x2, out y2);
+                       NativeMethods.cairo_rectangle (handle, x1, y1, x2 - x1, y2 - y1); 
+               }
                public bool InStroke (double x, double y)
                {
                        return NativeMethods.cairo_in_stroke (handle, x, y);

diff --git a/src/Mono.Cairo/NativeMethods.cs b/src/Mono.Cairo/NativeMethods.cs
index ab36a40ca14a672f4c28034f6b53e8e01e281db3..8286e2c20c9c2afd5331ae386e9c0222116bde8d 100644 (file)
--- a/src/Mono.Cairo/NativeMethods.cs
+++ b/src/Mono.Cairo/NativeMethods.cs
@@ -18,10 +18,10 @@
 // distribute, sublicense, and/or sell copies of the Software, and to
 // permit persons to whom the Software is furnished to do so, subject to
 // the following conditions:
-// 
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
-// 
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -46,74 +46,74 @@ namespace Cairo
 #else
                const string cairo = "libcairo-2.dll";
 #endif
-               
+
                //[DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                //internal static extern void cairo_append_path (IntPtr cr, Path path);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_arc (IntPtr cr, double xc, double yc, double radius, double angle1, double angle2);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_arc_negative (IntPtr cr, double xc, double yc, double radius, double angle1, double angle2);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_atsui_font_face_create_for_atsu_font_id (IntPtr font_id);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_clip (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_clip_preserve (IntPtr cr);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_clip_extents (IntPtr cr, out double x1, out double y1, out double x2, out double y2);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_close_path (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_copy_page (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_copy_path (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_copy_path_flat (IntPtr cr);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_append_path (IntPtr cr, IntPtr path);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_create (IntPtr target);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_curve_to (IntPtr cr, double x1, double y1, double x2, double y2, double x3, double y3);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_debug_reset_static_data ();
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_destroy (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_device_to_user (IntPtr cr, ref double x, ref double y);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_device_to_user_distance (IntPtr cr, ref double dx, ref double dy);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_fill (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_fill_extents (IntPtr cr, out double x1, out double y1, out double x2, out double y2);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_fill_preserve (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_font_extents (IntPtr cr, out FontExtents extents);
-               
-               // FontFace
+
+               #region FontFace
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_font_face_destroy (IntPtr font_face);
 
@@ -122,162 +122,165 @@ namespace Cairo
 
                //[DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                //internal static extern void cairo_font_face_get_user_data (IntPtr font_face);
-               
+
                //[DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                //internal static extern void cairo_font_face_set_user_data (IntPtr font_face);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_font_face_reference (IntPtr font_face);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern Status cairo_font_face_status (IntPtr font_face);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern uint cairo_font_face_get_reference_count (IntPtr surface);
-               
-               // FontOptions
+               #endregion
+
+               #region FontOptions
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_font_options_copy (IntPtr original);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_font_options_create ();
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_font_options_destroy (IntPtr options);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                [return: MarshalAs (UnmanagedType.U1)]
                internal static extern bool cairo_font_options_equal (IntPtr options, IntPtr other);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern Antialias cairo_font_options_get_antialias (IntPtr options);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern HintMetrics cairo_font_options_get_hint_metrics (IntPtr options);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern HintStyle cairo_font_options_get_hint_style (IntPtr options);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern SubpixelOrder cairo_font_options_get_subpixel_order (IntPtr options);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern long cairo_font_options_hash (IntPtr options);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_font_options_merge (IntPtr options, IntPtr other);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_font_options_set_antialias (IntPtr options, Antialias aa);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_font_options_set_hint_metrics (IntPtr options, HintMetrics metrics);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_font_options_set_hint_style (IntPtr options, HintStyle style);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_font_options_set_subpixel_order (IntPtr options, SubpixelOrder order);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern Status cairo_font_options_status (IntPtr options);
-               
-               // Freetype / FontConfig 
+               #endregion
+
+               #region Freetype / FontConfig
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_ft_font_face_create_for_ft_face (IntPtr face, int load_flags);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_ft_font_face_create_for_pattern (IntPtr fc_pattern);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_ft_font_options_substitute (FontOptions options, IntPtr pattern);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_ft_scaled_font_lock_face (IntPtr scaled_font);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_ft_scaled_font_unlock_face (IntPtr scaled_font);
-               
+               #endregion
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern Antialias cairo_get_antialias (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_get_current_point (IntPtr cr, out double x, out double y);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern FillRule cairo_get_fill_rule (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_get_font_face (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_get_font_matrix (IntPtr cr, out Matrix matrix);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_get_font_options (IntPtr cr, IntPtr options);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_get_group_target (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern LineCap cairo_get_line_cap (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern LineJoin cairo_get_line_join (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern double cairo_get_line_width (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_get_matrix (IntPtr cr, Matrix matrix);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern double cairo_get_miter_limit (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern Operator cairo_get_operator (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern uint cairo_get_reference_count (IntPtr surface);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_get_source (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_get_target (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern double cairo_get_tolerance (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_glitz_surface_create (IntPtr surface);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_glyph_extents (IntPtr cr, IntPtr glyphs, int num_glyphs, out TextExtents extents);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_glyph_path (IntPtr cr, IntPtr glyphs, int num_glyphs);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                [return: MarshalAs (UnmanagedType.U1)]
                internal static extern bool cairo_has_current_point (IntPtr cr);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_identity_matrix (IntPtr cr);
-               
-               // ImageSurface
+
+               #region Image Surface
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_image_surface_create (Cairo.Format format, int width, int height);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_image_surface_create_for_data (byte[] data, Cairo.Format format, int width, int height, int stride);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_image_surface_create_for_data (IntPtr data, Cairo.Format format, int width, int height, int stride);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_image_surface_create_from_png  (string filename);
-               
+
                //[DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                //internal static extern IntPtr cairo_image_surface_create_from_png_stream  (string filename);
 
@@ -286,15 +289,16 @@ namespace Cairo
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern Format cairo_image_surface_get_format (IntPtr surface);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern int cairo_image_surface_get_height (IntPtr surface);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern int cairo_image_surface_get_stride (IntPtr surface);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern int cairo_image_surface_get_width  (IntPtr surface);
+               #endregion
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                [return: MarshalAs (UnmanagedType.U1)]
@@ -303,79 +307,80 @@ namespace Cairo
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                [return: MarshalAs (UnmanagedType.U1)]
                internal static extern bool cairo_in_fill (IntPtr cr, double x, double y);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                [return: MarshalAs (UnmanagedType.U1)]
                internal static extern bool cairo_in_stroke (IntPtr cr, double x, double y);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_line_to (IntPtr cr, double x, double y);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_mask (IntPtr cr, IntPtr pattern);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_mask_surface (IntPtr cr, IntPtr surface, double x, double y);
-               
-               // Matrix
+
+               #region Matrix
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_matrix_init (Matrix matrix, double xx, double yx, double xy, double yy, double x0, double y0);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_matrix_init_identity (Matrix matrix);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_matrix_init_rotate (Matrix matrix, double radians);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_matrix_init_scale (Matrix matrix, double sx, double sy);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_matrix_init_translate (Matrix matrix, double tx, double ty);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern Status cairo_matrix_invert (Matrix matrix);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_matrix_multiply (Matrix result, Matrix a, Matrix b);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_matrix_scale (Matrix matrix, double sx, double sy);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_matrix_rotate (Matrix matrix, double radians);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_matrix_transform_distance (Matrix matrix, ref double dx, ref double dy);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_matrix_transform_point (Matrix matrix, ref double x, ref double y);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_matrix_translate (Matrix matrix, double tx, double ty);
-               
+               #endregion
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_move_to (IntPtr cr, double x, double y);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_new_path (IntPtr cr);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_new_sub_path (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_paint (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_paint_with_alpha (IntPtr cr, double alpha);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_path_destroy (IntPtr path);
-               
-               // Pattern
+
+               #region Pattern
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_pattern_add_color_stop_rgb (IntPtr pattern, double offset, double red, double green, double blue);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_pattern_add_color_stop_rgba (IntPtr pattern, double offset, double red, double green, double blue, double alpha);
 
@@ -383,91 +388,94 @@ namespace Cairo
                internal static extern Status cairo_pattern_get_color_stop_count (IntPtr pattern, out int count);
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern Status cairo_pattern_get_color_stop_rgba (IntPtr pattern, int index, out double offset, out double red, out double green, out double blue, out double alpha);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_pattern_create_for_surface (IntPtr surface);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern Status cairo_pattern_get_surface (IntPtr pattern, out IntPtr surface);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_pattern_create_linear (double x0, double y0, double x1, double y1);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern Status cairo_pattern_get_linear_points (IntPtr pattern, out double x0, out double y0, out double x1, out double y1);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_pattern_create_radial (double cx0, double cy0, double radius0, double cx1, double cy1, double radius1);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern Status cairo_pattern_get_radial_circles (IntPtr pattern, out double x0, out double y0, out double r0, out double x1, out double y1, out double r1);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_pattern_create_rgb (double r, double g, double b);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_pattern_create_rgba (double r, double g, double b, double a);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern Status cairo_pattern_get_rgba (IntPtr pattern, out double red, out double green, out double blue, out double alpha);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_pattern_destroy (IntPtr pattern);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern Extend cairo_pattern_get_extend (IntPtr pattern);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern Filter cairo_pattern_get_filter (IntPtr pattern);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_pattern_get_matrix (IntPtr pattern, Matrix matrix);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern PatternType cairo_pattern_get_type (IntPtr pattern);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_pattern_reference (IntPtr pattern);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_pattern_set_extend (IntPtr pattern, Extend extend);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_pattern_set_filter (IntPtr pattern, Filter filter);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_pattern_set_matrix (IntPtr pattern, Matrix matrix);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern Status cairo_pattern_status (IntPtr pattern);
-       
-               // PdfSurface
+               #endregion
+
+               #region PdfSurface
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_pdf_surface_create (string filename, double width, double height);
-               
+
                //[DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                //internal static extern IntPtr cairo_pdf_surface_create_for_stream (string filename, double width, double height);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_pdf_surface_set_size (IntPtr surface, double x, double y);
-               
-               // PostscriptSurface
+               #endregion
+
+               #region PostscriptSurface
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_ps_surface_create (string filename, double width, double height);
-               
+
                //[DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                //internal static extern IntPtr cairo_ps_surface_create_for_stream (string filename, double width, double height);
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_ps_surface_dsc_begin_page_setup (IntPtr surface);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_ps_surface_dsc_begin_setup (IntPtr surface);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_ps_surface_dsc_comment (IntPtr surface, string comment);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_ps_surface_set_size (IntPtr surface, double x, double y);
+               #endregion
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_pop_group (IntPtr cr);
@@ -486,15 +494,16 @@ namespace Cairo
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_rectangle (IntPtr cr, double x, double y, double width, double height);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_reference (IntPtr cr);
-               
+
+               #region Regions
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern bool cairo_region_contains_point (IntPtr region, int x, int y);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
-               internal static extern RegionOverlap cairo_region_contains_rectangle (IntPtr region, ref RectangleInt rectangle);
+               internal static extern RegionOverlap cairo_region_contains_rectangle (IntPtr region, ref Crow.Rectangle rectangle);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_region_copy (IntPtr original);
@@ -503,10 +512,10 @@ namespace Cairo
                internal static extern IntPtr cairo_region_create ();
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
-               internal static extern IntPtr cairo_region_create_rectangle (ref RectangleInt rect);
+               internal static extern IntPtr cairo_region_create_rectangle (ref Crow.Rectangle rect);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
-               internal static extern IntPtr cairo_region_create_rectangles (RectangleInt[] rects, int count);
+               internal static extern IntPtr cairo_region_create_rectangles (IntPtr rects, int count);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_region_destroy (IntPtr region);
@@ -515,16 +524,16 @@ namespace Cairo
                internal static extern bool cairo_region_equal (IntPtr a, IntPtr b);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
-               internal static extern void cairo_region_get_extents (IntPtr region, out RectangleInt extents);
+               internal static extern void cairo_region_get_extents (IntPtr region, out Crow.Rectangle extents);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
-               internal static extern void cairo_region_get_rectangle (IntPtr region, int nth, out RectangleInt rectangle);
+               internal static extern void cairo_region_get_rectangle (IntPtr region, int nth, out Crow.Rectangle rectangle);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern Status cairo_region_intersect (IntPtr dst, IntPtr other);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
-               internal static extern Status cairo_region_intersect_rectangle (IntPtr dst, ref RectangleInt rectangle);
+               internal static extern Status cairo_region_intersect_rectangle (IntPtr dst, ref Crow.Rectangle rectangle);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern bool cairo_region_is_empty (IntPtr region);
@@ -542,7 +551,7 @@ namespace Cairo
                internal static extern Status cairo_region_subtract (IntPtr dst, IntPtr other);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
-               internal static extern Status cairo_region_subtract_rectangle (IntPtr dst, ref RectangleInt rectangle);
+               internal static extern Status cairo_region_subtract_rectangle (IntPtr dst, ref Crow.Rectangle rectangle);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_region_translate (IntPtr region, int dx, int dy);
@@ -551,45 +560,46 @@ namespace Cairo
                internal static extern Status cairo_region_union (IntPtr dst, IntPtr other);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
-               internal static extern Status cairo_region_union_rectangle (IntPtr dst, ref RectangleInt rectangle);
+               internal static extern Status cairo_region_union_rectangle (IntPtr dst, ref Crow.Rectangle rectangle);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern Status cairo_region_xor (IntPtr dst, IntPtr other);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
-               internal static extern Status cairo_region_xor_rectangle (IntPtr dst, ref RectangleInt rectangle);
+               internal static extern Status cairo_region_xor_rectangle (IntPtr dst, ref Crow.Rectangle rectangle);
+               #endregion
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_rel_curve_to (IntPtr cr, double dx1, double dy1, double dx2, double dy2, double dx3, double dy3);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_rel_line_to (IntPtr cr, double dx, double dy);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_rel_move_to (IntPtr cr, double dx, double dy);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_reset_clip (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_restore (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_rotate (IntPtr cr, double angle);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_save (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_scale (IntPtr cr, double sx, double sy);
-               
-               // ScaledFont
+
+               #region ScaledFont
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_scaled_font_create (IntPtr fontFace, Matrix matrix, Matrix ctm, IntPtr options);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_scaled_font_destroy (IntPtr scaled_font);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_scaled_font_extents (IntPtr scaled_font, out FontExtents extents);
 
@@ -610,7 +620,7 @@ namespace Cairo
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_scaled_font_glyph_extents (IntPtr scaled_font, IntPtr glyphs, int num_glyphs, out TextExtents extents);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_scaled_font_reference (IntPtr scaled_font);
 
@@ -625,13 +635,14 @@ namespace Cairo
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_scaled_font_text_extents (IntPtr scaled_font, byte[] utf8, out TextExtents extents);
-               
+               #endregion
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_select_font_face (IntPtr cr, string family, FontSlant slant, FontWeight weight);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_set_antialias (IntPtr cr, Antialias antialias);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_set_dash (IntPtr cr, double [] dashes, int ndash, double offset);
 
@@ -640,101 +651,101 @@ namespace Cairo
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern int cairo_get_dash_count (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_set_fill_rule (IntPtr cr, Cairo.FillRule fill_rule);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_set_font_face (IntPtr cr, IntPtr fontFace);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_set_font_matrix (IntPtr cr, Matrix matrix);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_set_font_options (IntPtr cr, IntPtr options);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_set_font_size (IntPtr cr, double size);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_set_line_cap (IntPtr cr, LineCap line_cap);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_set_line_join (IntPtr cr, LineJoin line_join);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_set_line_width (IntPtr cr, double width);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_set_matrix (IntPtr cr, Matrix matrix);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_set_miter_limit (IntPtr cr, double limit);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_set_operator (IntPtr cr, Cairo.Operator op);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_set_source (IntPtr cr, IntPtr pattern);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_set_source_rgb (IntPtr cr, double red, double green, double blue);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_set_source_rgba (IntPtr cr, double red, double green, double blue, double alpha);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_set_source_surface (IntPtr cr, IntPtr surface, double x, double y);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_set_tolerance (IntPtr cr, double tolerance);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_show_glyphs (IntPtr ct, IntPtr glyphs, int num_glyphs);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_show_page (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_show_text (IntPtr cr, byte[] utf8);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern Status cairo_status (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_status_to_string (Status status);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_stroke (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_stroke_extents (IntPtr cr, out double x1, out double y1, out double x2, out double y2);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_stroke_preserve (IntPtr cr);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_rectangle_list_destroy (IntPtr rectangle_list);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_copy_clip_rectangle_list (IntPtr cr);
 
-               // Surface
+               #region Surface
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_surface_create_similar (IntPtr surface, Cairo.Content content, int width, int height);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_surface_destroy (IntPtr surface);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_surface_finish (IntPtr surface);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_surface_flush (IntPtr surface);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern Content cairo_surface_get_content (IntPtr surface);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_surface_get_device_offset (IntPtr surface, out double x, out double y);
 
@@ -746,105 +757,112 @@ namespace Cairo
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern SurfaceType cairo_surface_get_type (IntPtr surface);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_surface_mark_dirty (IntPtr surface);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_surface_mark_dirty_rectangle (IntPtr surface, int x, int y, int width, int height);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_surface_reference (IntPtr surface);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_surface_set_device_offset (IntPtr surface, double x, double y);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_surface_set_fallback_resolution (IntPtr surface, double x, double y);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern Status cairo_surface_status (IntPtr surface);
-               
+               #endregion
+
+               #region SVG surface
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_surface_write_to_png (IntPtr surface, string filename);
-               
+
                //[DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                //internal static extern void cairo_surface_write_to_png_stream (IntPtr surface, WriteFunc writeFunc);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_svg_surface_create (string fileName, double width, double height);
-               
+
                //[DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                //internal static extern IntPtr cairo_svg_surface_create_for_stream (double width, double height);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_svg_surface_restrict_to_version (IntPtr surface, SvgVersion version);
-               
+               #endregion
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_text_extents (IntPtr cr, byte[] utf8, out TextExtents extents);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_text_path (IntPtr ct, byte[] utf8);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_transform (IntPtr cr, Matrix matrix);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_translate (IntPtr cr, double tx, double ty);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_user_to_device (IntPtr cr, ref double x, ref double y);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_user_to_device_distance (IntPtr cr, ref double dx, ref double dy);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern int cairo_version ();
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_version_string ();
-               
-               // DirectFBSurface
+
+               #region DirectFBSurface
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_directfb_surface_create (IntPtr dfb, IntPtr surface);
-               
-               // win32 fonts
+               #endregion
+
+               #region win32 fonts
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_win32_font_face_create_for_logfontw (IntPtr logfontw);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_win32_scaled_font_done_font (IntPtr scaled_font);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern double cairo_win32_scaled_font_get_metrics_factor (IntPtr scaled_font);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern Status cairo_win32_scaled_font_select_font (IntPtr scaled_font, IntPtr hdc);
-               
-               // win32 surface
+               #endregion
+
+               #region win32 surface
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_win32_surface_create (IntPtr hdc);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_win32_surface_create_with_ddb (IntPtr hdc, Format format, int width, int height);
+               #endregion
 
-               // XcbSurface
+               #region XcbSurface
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_xcb_surface_create (IntPtr connection, uint drawable, IntPtr visual, int width, int height);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_xcb_surface_create_for_bitmap (IntPtr connection, uint bitmap, IntPtr screen, int width, int height);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_xcb_surface_set_size (IntPtr surface, int width, int height);
-               
-               // XlibSurface
+               #endregion
+
+               #region XlibSurface
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_xlib_surface_create (IntPtr display, IntPtr drawable, IntPtr visual, int width, int height);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern IntPtr cairo_xlib_surface_create_for_bitmap (IntPtr display, IntPtr bitmap, IntPtr screen, int width, int height);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern int cairo_xlib_surface_get_depth (IntPtr surface);
 
@@ -865,12 +883,16 @@ namespace Cairo
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern int cairo_xlib_surface_get_width (IntPtr surface);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_xlib_surface_set_drawable (IntPtr surface, IntPtr drawable, int width, int height);
-               
+
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_xlib_surface_set_size (IntPtr surface, int width, int height);
+               #endregion
+
+               [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
+               internal static extern void cairo_gl_device_set_thread_aware(IntPtr device, int value);
 
                #region GLSurface
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
@@ -980,22 +1002,19 @@ namespace Cairo
 
                #region Device
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
-               internal static extern IntPtr cairo_device_reference (IntPtr device);
-
-               [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
-               internal static extern Status cairo_device_status(IntPtr device);
+               internal static extern Status cairo_device_acquire(IntPtr device);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_device_destroy (IntPtr device);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
-               internal static extern Status cairo_device_acquire(IntPtr device);
+               internal static extern IntPtr cairo_device_reference (IntPtr device);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
                internal static extern void cairo_device_release(IntPtr device);
 
                [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)]
-               internal static extern void cairo_gl_device_set_thread_aware(IntPtr device, int value);
+               internal static extern Status cairo_device_status(IntPtr device);
                #endregion
        }
 }
\ No newline at end of file

diff --git a/src/Mono.Cairo/Region.cs b/src/Mono.Cairo/Region.cs
index cd0ba33fde2ba93d694622c675a503bbb65b1d13..4a82842ae5c05743f13c7fca1029cd5539dda311 100644 (file)
--- a/src/Mono.Cairo/Region.cs
+++ b/src/Mono.Cairo/Region.cs
@@ -25,13 +25,11 @@ using System.Runtime.InteropServices;
 
 namespace Cairo
 {
-
        [StructLayout(LayoutKind.Sequential)]
-       public struct RectangleInt {
-               public int X;
-               public int Y;
-               public int Width;
-               public int Height;
+       public struct RectangleList {
+               public Status Status;
+               public IntPtr Rectangles;
+               public int NumRectangles;
        }
 
        public enum RegionOverlap {
@@ -63,14 +61,14 @@ namespace Cairo
                {
                }
 
-               public Region (RectangleInt rect)
+               public Region (Crow.Rectangle rect)
                {
                        handle = NativeMethods.cairo_region_create_rectangle (ref rect);
                }
 
-               public Region (RectangleInt[] rects)
+               public Region (RectangleList rects)
                {
-                       handle = NativeMethods.cairo_region_create_rectangles (rects, rects.Length);
+                       handle = NativeMethods.cairo_region_create_rectangles (rects.Rectangles, rects.NumRectangles);
                }
 
                public Region Copy ()
@@ -78,6 +76,7 @@ namespace Cairo
                        return new Region (NativeMethods.cairo_region_copy (Handle), true);
                }
 
+               #region IDisposable
                ~Region ()
                {
                        Dispose (false);
@@ -100,6 +99,7 @@ namespace Cairo
                        NativeMethods.cairo_region_destroy (Handle);
                        handle = IntPtr.Zero;
                }
+               #endregion
 
                public override bool Equals (object obj)
                {
@@ -115,9 +115,9 @@ namespace Cairo
                        get { return NativeMethods.cairo_region_status (Handle); }
                }
 
-               public RectangleInt Extents {
+               public Crow.Rectangle Extents {
                        get {
-                               RectangleInt result;
+                               Crow.Rectangle result;
                                NativeMethods.cairo_region_get_extents (Handle, out result);
                                return result;
                        }
@@ -127,9 +127,9 @@ namespace Cairo
                        get { return NativeMethods.cairo_region_num_rectangles (Handle); }
                }
 
-               public RectangleInt GetRectangle (int nth)
+               public Crow.Rectangle GetRectangle (int nth)
                {
-                       RectangleInt val;
+                       Crow.Rectangle val;
                        NativeMethods.cairo_region_get_rectangle (Handle, nth, out val);
                        return val;
                }
@@ -138,12 +138,12 @@ namespace Cairo
                        get { return NativeMethods.cairo_region_is_empty (Handle); }
                }
 
-               public RegionOverlap ContainsPoint (RectangleInt rectangle)
+               public RegionOverlap Contains (Crow.Rectangle rectangle)
                {
                        return NativeMethods.cairo_region_contains_rectangle (Handle, ref rectangle);
                }
 
-               public bool ContainsPoint (int x, int y)
+               public bool Contains (int x, int y)
                {
                        return NativeMethods.cairo_region_contains_point (Handle, x, y);
                }
@@ -158,7 +158,7 @@ namespace Cairo
                        return NativeMethods.cairo_region_subtract (Handle, other.Handle);
                }
 
-               public Status SubtractRectangle (RectangleInt rectangle)
+               public Status SubtractRectangle (Crow.Rectangle rectangle)
                {
                        return NativeMethods.cairo_region_subtract_rectangle (Handle, ref rectangle);
                }
@@ -168,7 +168,7 @@ namespace Cairo
                        return NativeMethods.cairo_region_intersect (Handle, other.Handle);
                }
 
-               public Status IntersectRectangle (RectangleInt rectangle)
+               public Status IntersectRectangle (Crow.Rectangle rectangle)
                {
                        return NativeMethods.cairo_region_intersect_rectangle (Handle, ref rectangle);
                }
@@ -178,7 +178,7 @@ namespace Cairo
                        return NativeMethods.cairo_region_union (Handle, other.Handle);
                }
 
-               public Status UnionRectangle (RectangleInt rectangle)
+               public Status UnionRectangle (Crow.Rectangle rectangle)
                {
                        return NativeMethods.cairo_region_union_rectangle (Handle, ref rectangle);
                }
@@ -188,7 +188,7 @@ namespace Cairo
                        return NativeMethods.cairo_region_xor (Handle, other.Handle);
                }
 
-               public Status XorRectangle (RectangleInt rectangle)
+               public Status XorRectangle (Crow.Rectangle rectangle)
                {
                        return NativeMethods.cairo_region_xor_rectangle (Handle, ref rectangle);
                }

diff --git a/src/PerformanceMeasure.cs b/src/PerformanceMeasure.cs
index 172f926d6a298050a72fc52adaf7f6033803800e..3c978e8b473e379353b63c7aee19e80300eca9f1 100644 (file)
--- a/src/PerformanceMeasure.cs
+++ b/src/PerformanceMeasure.cs
@@ -72,8 +72,8 @@ namespace Crow
 
                void computeStats(){                    
                        current = timer.ElapsedTicks;
-//                     if (current < cancelLimit)
-//                             return;
+                       if (current < cancelLimit)
+                               return;
                        cptMeasures++;
                        total += timer.ElapsedTicks;
                        if (timer.ElapsedTicks < minimum)

diff --git a/src/Rectangle.cs b/src/Rectangle.cs
index 574dc3c4ea08f566448eaa22cbf97b40dd982ee0..256c79442a4ac08b2917855579133c4bc420e9a6 100644 (file)
--- a/src/Rectangle.cs
+++ b/src/Rectangle.cs
@@ -28,73 +28,50 @@ using System;
 using System.Collections.Generic;
 using System.Text;
 using System.Xml.Serialization;
+using System.Runtime.InteropServices;
 
 namespace Crow
-{    
+{
+       [StructLayout(LayoutKind.Sequential)]
        public struct Rectangle
     {
                internal static Type TRectangle = typeof(Rectangle);
-               #region private fields
-        int _x;
-        int _y;
-        int _width;
-        int _height;
-               #endregion
+
+               public int X;
+               public int Y;
+               public int Width;
+               public int Height;
 
                #region ctor
-        public Rectangle(Point p, Size s)
-        {
-            _x = p.X;
-            _y = p.Y;
-            _width = s.Width;
-            _height = s.Height;
-        }
-        public Rectangle(Size s)
+               public Rectangle(Point p, Size s): this (p.X, p.Y, s.Width, s.Height)
+               {
+               }
+               public Rectangle(Size s) : this (0, 0, s.Width, s.Height)
         {
-            _x = 0;
-            _y = 0;
-            _width = s.Width;
-            _height = s.Height;
         }
         public Rectangle(int x, int y, int width, int height)
         {
-            _x = x;
-            _y = y;
-            _width = width;
-            _height = height;
+                       X = x;
+                       Y = y;
+                       Width = width;
+                       Height = height;
         }
                #endregion
 
                #region PROPERTIES
-        [XmlIgnore]public int X{
-            get { return _x; }
-            set { _x = value; }
-        }
-               [XmlIgnore]public int Y{
-            get { return _y; }
-            set { _y = value; }
-        }
                [XmlIgnore]public int Left{
-            get { return _x; }
-            set { _x = value; }
+            get { return X; }
+            set { X = value; }
         }
                [XmlIgnore]public int Top{
-            get { return _y; }
-            set { _y = value; }
+            get { return Y; }
+            set { Y = value; }
         }
                [XmlIgnore]public int Right{
-            get { return _x + _width; }
+            get { return X + Width; }
         }
                [XmlIgnore]public int Bottom{
-            get { return _y + _height; }
-        }
-               [XmlIgnore]public int Width{
-            get { return _width; }
-            set { _width = value; }
-        }
-               [XmlIgnore]public int Height{
-            get { return _height; }
-            set { _height = value; }
+            get { return Y + Height; }
         }
                [XmlIgnore]public Size Size{
             get { return new Size(Width, Height); }
@@ -169,7 +146,7 @@ namespace Crow
         public Rectangle Intersection(Rectangle r)
         {
             Rectangle result = new Rectangle();
-            
+
             if (r.Left >= this.Left)
                 result.Left = r.Left;
             else
@@ -227,7 +204,7 @@ namespace Crow
         {
             return r1.TopLeft == r2.TopLeft && r1.Size == r2.Size ? false : true;
         }
-        #endregion        
+        #endregion
 
                public static readonly Rectangle Zero = new Rectangle(0, 0, 0, 0);
         public static Rectangle Empty
@@ -253,10 +230,10 @@ namespace Crow
                        {
                                int hash = 17;
                                // Suitable nullity checks etc, of course :)
-                               hash = hash * 23 + _x.GetHashCode();
-                               hash = hash * 23 + _y.GetHashCode();
-                               hash = hash * 23 + _width.GetHashCode();
-                               hash = hash * 23 + _height.GetHashCode();
+                               hash = hash * 23 + X.GetHashCode();
+                               hash = hash * 23 + Y.GetHashCode();
+                               hash = hash * 23 + Width.GetHashCode();
+                               hash = hash * 23 + Height.GetHashCode();
                                return hash;
                        }
                }

diff --git a/src/Rectangles.cs b/src/Rectangles.cs
deleted file mode 100644 (file)
index 7310290..0000000
--- a/src/Rectangles.cs
+++ /dev/null
@@ -1,137 +0,0 @@
-//
-// Rectangles.cs
-//
-// Author:
-//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
-//
-// Copyright (c) 2013-2017 Jean-Philippe Bruyère
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Cairo;
-using System.Diagnostics;
-
-namespace Crow
-{
-    public class Rectangles
-    {
-        public List<Rectangle> list = new List<Rectangle>();
-        public int count
-        {
-            get { return list.Count; }
-        }
-
-        public void AddRectangle(Rectangle r)
-        {
-                       if (doesNotContain (r)) {
-                               list.Add (r);
-                               boundsUpToDate = false;
-                       }
-        }
-        public void Reset()
-        {
-            list = new List<Rectangle>();
-                       _bounds = Rectangle.Empty;
-                       boundsUpToDate = true;
-        }
-        bool doesNotContain(Rectangle r)
-        {
-            foreach (Rectangle rInList in list)
-                if (rInList.ContainsOrIsEqual(r))
-                    return false;
-            return true;
-        }
-
-        public bool intersect(Rectangle r)
-        {
-            foreach (Rectangle rInList in list)
-                if (rInList.Intersect(r))
-                    return true;
-            return false;
-        }
-               public void stroke(Context ctx, Color c)
-               {
-                       foreach (Rectangle r in list)
-                               ctx.Rectangle(r);
-
-                       ctx.SetSourceColor(c);
-
-                       ctx.LineWidth = 2;
-                       ctx.Stroke ();
-               }
-        public void clearAndClip(Context ctx)
-        {
-                       if (list.Count == 0)
-                               return;
-            foreach (Rectangle r in list)
-                ctx.Rectangle(r);
-
-                       ctx.ClipPreserve();
-                       ctx.Operator = Operator.Clear;
-            ctx.Fill();
-            ctx.Operator = Operator.Over;
-        }
-
-        public void clip(Context ctx)
-        {
-            foreach (Rectangle r in list)
-               ctx.Rectangle(r);
-
-            ctx.Clip();
-        }
-
-               Rectangle _bounds;
-               bool boundsUpToDate = true;
-               public Rectangle Bounds {
-                       get {
-                               if (!boundsUpToDate) {
-                                       if (list.Count > 0) {
-                                               _bounds = list [0];
-                                               for (int i = 1; i < list.Count; i++) {
-                                                       _bounds += list [i];
-                                               }
-                                       } else
-                                               _bounds = Rectangle.Empty;
-                                       boundsUpToDate = true;
-                               }
-                               return _bounds;
-                       }
-               }
-               public void clear(Context ctx)
-        {
-            foreach (Rectangle r in list)
-                ctx.Rectangle(r);
-            ctx.Operator = Operator.Clear;
-            ctx.Fill();
-            ctx.Operator = Operator.Over;
-        }
-               public override string ToString ()
-               {
-                       string tmp = "";
-                       foreach (Rectangle r in list) {
-                               tmp += r.ToString ();
-                       }
-                       return tmp;
-               }
-    }
-}

diff --git a/testDrm/TestCrow.cs b/testDrm/TestCrow.cs
new file mode 100644 (file)
index 0000000..78b76ee
--- /dev/null
+++ b/testDrm/TestCrow.cs
@@ -0,0 +1,45 @@
+//
+// TestCrow.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+using System;
+using Crow;
+
+namespace testDrm
+{
+       public class TestCrow
+       {
+               static void Main(){
+                       Rectangle bounds = new Rectangle(0,0,1024,768);
+                       Interface iface = new Interface();
+                       iface.ProcessResize (bounds);
+
+                       iface.LoadInterface ("#testDrm.ui.go.crow");
+
+                       while (true)
+                               iface.Update ();
+               }
+       }
+}
+

diff --git a/testDrm/testCairo.cs b/testDrm/testCairo.cs
new file mode 100644 (file)
index 0000000..1e54473
--- /dev/null
+++ b/testDrm/testCairo.cs
@@ -0,0 +1,58 @@
+//
+// testCairo.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+using System;
+using Cairo;
+using System.Runtime.InteropServices;
+
+namespace testDrm
+{
+       public class testCairo
+       {
+
+               static void Main(){
+                       test ();
+               }
+               static void test(){
+                       using (Surface s = new ImageSurface (Format.Argb32, 500,500)){
+                               using (Context ctx = new Context (s)) {
+                                       ctx.Rectangle (100, 100, 200, 200);
+                                       ctx.Rectangle (50, 50, 50, 50);
+                                       ctx.Clip ();
+                                       ctx.Rectangle (0, 0, 400, 400);
+                                       ctx.SetSourceRGB (1, 0, 0);
+                                       ctx.Fill ();
+                                       //IntPtr rects = ctx.GetClipRectangles ();
+
+                                       RectangleList rl = ctx.GetClipRectangles ();//(RectangleList)Marshal.PtrToStructure (rects, typeof(RectangleList));
+                                       Console.WriteLine ("num rects: {0}", rl.NumRectangles);
+                               }
+                               s.WriteToPng ("/home/jp/test.png");
+                       }
+               }
+
+       }
+}
+

diff --git a/testDrm/testDrm.csproj b/testDrm/testDrm.csproj
index b7402251205013be633a6ef85eb7ae5f3f4cc377..9a8d42918921670a5d4e8e3392fb7e30a37a6168 100644 (file)
--- a/testDrm/testDrm.csproj
+++ b/testDrm/testDrm.csproj
@@ -73,6 +73,8 @@
     <Compile Include="defineToEnum.cs" />
     <Compile Include="src\EVDEV\Enums.cs" />
     <Compile Include="src\Linux\DRIControler.cs" />
+    <Compile Include="testCairo.cs" />
+    <Compile Include="TestCrow.cs" />
   </ItemGroup>
   <ItemGroup>
     <Reference Include="System" />
@@ -110,6 +112,7 @@
     <EmbeddedResource Include="ui\perfMeasures.crow">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </EmbeddedResource>
+    <EmbeddedResource Include="ui\go.crow" />
   </ItemGroup>
   <ItemGroup>
     <None Include="src\DRMContext.cs" />

diff --git a/testDrm/tests.cs b/testDrm/tests.cs
index 8e52c86389b7fa016d9673df420407cc5ae223be..3160070646d073886cf4b3a1fb71e63b36d9c16c 100644 (file)
--- a/testDrm/tests.cs
+++ b/testDrm/tests.cs
@@ -49,19 +49,6 @@ namespace testDrm
        {
                static void Main ()
                {
-//                     using (VTControler vt = new VTControler()){
-//                             Console.WriteLine (vt.CurrentVT);
-//
-//                             for (byte i = 0; i < 0x7F; i++) {
-//                                     Console.Write ("{0:X2}: ", i);
-//                                     printke (vt.GetKDBEntry (KbTable.Normal, i));
-//                                     printke (vt.GetKDBEntry (KbTable.Shift, i));
-//                                     printke (vt.GetKDBEntry (KbTable.Alt, i));
-//                                     Console.Write ("\n");
-//                             }
-//                     }
-//                     //return;
-                       testEVDEV ();
                }
 //             static void printke(KbEntry ke){
 //                     string output = "";

diff --git a/testDrm/ui/go.crow b/testDrm/ui/go.crow
new file mode 100755 (executable)
index 0000000..c3eda9c
--- /dev/null
+++ b/testDrm/ui/go.crow
@@ -0,0 +1,2 @@
+<?xml version="1.0"?>
+<GraphicObject Width="200" Height="200" Background="Mantis"/>
\ No newline at end of file