diff --git a/cairo/Context.cs b/cairo/Context.cs index 9cc0000dd..091afac7d 100644 --- a/cairo/Context.cs +++ b/cairo/Context.cs @@ -21,10 +21,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 @@ -188,12 +188,12 @@ namespace Cairo { public Graphics (Surface surface) : base (surface) {} } - public class Context : IDisposable - { - internal IntPtr state = IntPtr.Zero; + public class Context : IDisposable + { + IntPtr handle = IntPtr.Zero; static int native_glyph_size, c_compiler_long_size; - + static Context () { // @@ -207,7 +207,7 @@ namespace Cairo { // is 32 bits // int ptr_size = Marshal.SizeOf (typeof (IntPtr)); - + PlatformID platform = Environment.OSVersion.Platform; if (platform == PlatformID.Win32NT || platform == PlatformID.Win32S || @@ -221,365 +221,371 @@ namespace Cairo { native_glyph_size = Marshal.SizeOf (typeof (Glyph)); } } - - public Context (Surface surface) - { - state = NativeMethods.cairo_create (surface.Handle); - } - - public Context (IntPtr state) : this (state, true) {} - public Context (IntPtr state, bool owned) + public Context (Surface surface) : this (NativeMethods.cairo_create (surface.Handle), true) { - this.state = owned ? state : NativeMethods.cairo_reference (state); } - + + public Context (IntPtr handle, bool owner) + { + this.handle = handle; + if (!owner) + NativeMethods.cairo_reference (handle); + if (CairoDebug.Enabled) + CairoDebug.OnAllocated (handle); + } + + [Obsolete] + public Context (IntPtr state) : this (state, true) + { + } + ~Context () { Dispose (false); } - void IDisposable.Dispose () + public void Dispose () { Dispose (true); GC.SuppressFinalize (this); } - - protected virtual void Dispose (bool disposing) - { - if (!disposing || CairoDebug.Enabled) - CairoDebug.OnDisposed (state, disposing); - if (!disposing|| state == IntPtr.Zero) + protected virtual void Dispose (bool disposing) + { + if (!disposing || CairoDebug.Enabled) + CairoDebug.OnDisposed (handle, disposing); + + if (!disposing || handle == IntPtr.Zero) return; - //Console.WriteLine ("Destroying"); - NativeMethods.cairo_destroy (state); - state = IntPtr.Zero; - } + NativeMethods.cairo_destroy (handle); + handle = IntPtr.Zero; + } - public void Save () - { - NativeMethods.cairo_save (state); - } + public void Save () + { + NativeMethods.cairo_save (handle); + } - public void Restore () - { - NativeMethods.cairo_restore (state); - } + public void Restore () + { + NativeMethods.cairo_restore (handle); + } public Antialias Antialias { - get { return NativeMethods.cairo_get_antialias (state); } - set { NativeMethods.cairo_set_antialias (state, value); } + get { return NativeMethods.cairo_get_antialias (handle); } + set { NativeMethods.cairo_set_antialias (handle, value); } } - - public Cairo.Status Status { - get { - return NativeMethods.cairo_status (state); - } - } - - public IntPtr Handle { - get { - return state; - } - } - - public Cairo.Operator Operator { - set { - NativeMethods.cairo_set_operator (state, value); - } - get { - return NativeMethods.cairo_get_operator (state); - } - } - - //FIXME: obsolete this property - public Cairo.Color Color { - set { - NativeMethods.cairo_set_source_rgba (state, value.R, value.G, value.B, value.A); - } - } + public Cairo.Status Status { + get { + return NativeMethods.cairo_status (handle); + } + } - [Obsolete ("Use Color property")] - public Cairo.Color ColorRgb { - set { + public IntPtr Handle { + get { + return handle; + } + } + + public Operator Operator { + set { + NativeMethods.cairo_set_operator (handle, value); + } + + get { + return NativeMethods.cairo_get_operator (handle); + } + } + + [Obsolete ("Use SetSourceRGBA method")] + public Color Color { + set { + NativeMethods.cairo_set_source_rgba (handle, value.R, value.G, value.B, value.A); + } + } + + [Obsolete ("Use SetSourceRGBA method")] + public Cairo.Color ColorRgb { + set { Color = new Color (value.R, value.G, value.B); } - } - - public double Tolerance { - get { - return NativeMethods.cairo_get_tolerance (state); - } - - set { - NativeMethods.cairo_set_tolerance (state, value); - } - } - - public Cairo.FillRule FillRule { - set { - NativeMethods.cairo_set_fill_rule (state, value); - } - - get { - return NativeMethods.cairo_get_fill_rule (state); - } - } - - public double LineWidth { - set { - NativeMethods.cairo_set_line_width (state, value); - } - - get { - return NativeMethods.cairo_get_line_width (state); - } - } - - public Cairo.LineCap LineCap { - set { - NativeMethods.cairo_set_line_cap (state, value); - } - - get { - return NativeMethods.cairo_get_line_cap (state); - } - } - - public Cairo.LineJoin LineJoin { - set { - NativeMethods.cairo_set_line_join (state, value); - } - - get { - return NativeMethods.cairo_get_line_join (state); - } - } - - public void SetDash (double [] dashes, double offset) - { - NativeMethods.cairo_set_dash (state, dashes, dashes.Length, offset); - } - - public Pattern Pattern { - set { - NativeMethods.cairo_set_source (state, value.Handle); - } - - get { - return new Pattern (NativeMethods.cairo_get_source (state)); - } - } - - public Pattern Source { - set { - NativeMethods.cairo_set_source (state, value.Handle); - } - - get { - return Pattern.Lookup (NativeMethods.cairo_get_source (state)); - } - } - - public double MiterLimit { - set { - NativeMethods.cairo_set_miter_limit (state, value); - } - - get { - return NativeMethods.cairo_get_miter_limit (state); - } - } - - public PointD CurrentPoint { - get { - double x, y; - NativeMethods.cairo_get_current_point (state, out x, out y); - return new PointD (x, y); - } - } - - public bool HasCurrentPoint { - get { return NativeMethods.cairo_has_current_point (state); } } - public Cairo.Surface Target { - set { - if (state != IntPtr.Zero) - NativeMethods.cairo_destroy (state); - - state = NativeMethods.cairo_create (value.Handle); - } + public double Tolerance { + get { + return NativeMethods.cairo_get_tolerance (handle); + } - get { - return Cairo.Surface.LookupExternalSurface ( - NativeMethods.cairo_get_target (state)); - } - } + set { + NativeMethods.cairo_set_tolerance (handle, value); + } + } + + public Cairo.FillRule FillRule { + set { + NativeMethods.cairo_set_fill_rule (handle, value); + } + + get { + return NativeMethods.cairo_get_fill_rule (handle); + } + } + + public double LineWidth { + set { + NativeMethods.cairo_set_line_width (handle, value); + } + + get { + return NativeMethods.cairo_get_line_width (handle); + } + } + + public Cairo.LineCap LineCap { + set { + NativeMethods.cairo_set_line_cap (handle, value); + } + + get { + return NativeMethods.cairo_get_line_cap (handle); + } + } + + public Cairo.LineJoin LineJoin { + set { + NativeMethods.cairo_set_line_join (handle, value); + } + + get { + return NativeMethods.cairo_get_line_join (handle); + } + } + + public void SetDash (double [] dashes, double offset) + { + NativeMethods.cairo_set_dash (handle, dashes, dashes.Length, offset); + } + + [Obsolete("Use Source")] + public Pattern Pattern { + set { + Source = value; + } + + get { + return Source; + } + } + + public Pattern Source { + set { + NativeMethods.cairo_set_source (handle, value.Handle); + } + + get { + var ptr = NativeMethods.cairo_get_source (handle); + return Cairo.Pattern.Lookup (ptr, false); + } + } + + public double MiterLimit { + set { + NativeMethods.cairo_set_miter_limit (handle, value); + } + + get { + return NativeMethods.cairo_get_miter_limit (handle); + } + } + + public PointD CurrentPoint { + get { + double x, y; + NativeMethods.cairo_get_current_point (handle, out x, out y); + return new PointD (x, y); + } + } + + public bool HasCurrentPoint { + get { return NativeMethods.cairo_has_current_point (handle); } + } + + public Cairo.Surface Target { + set { + if (handle != IntPtr.Zero) + NativeMethods.cairo_destroy (handle); + + handle = NativeMethods.cairo_create (value.Handle); + } + + get { + return Surface.Lookup (NativeMethods.cairo_get_target (handle), false); + } + } public Cairo.ScaledFont ScaledFont { - set { - NativeMethods.cairo_set_scaled_font (state, value.Handle); - } + set { + NativeMethods.cairo_set_scaled_font (handle, value.Handle); + } - get { - return new ScaledFont (NativeMethods.cairo_get_scaled_font (state)); - } - } + get { + return new ScaledFont (NativeMethods.cairo_get_scaled_font (handle), false); + } + } public uint ReferenceCount { - get { return NativeMethods.cairo_get_reference_count (state); } + get { return NativeMethods.cairo_get_reference_count (handle); } } public void SetSourceRGB (double r, double g, double b) { - NativeMethods.cairo_set_source_rgb (state, r, g, b); + NativeMethods.cairo_set_source_rgb (handle, r, g, b); } public void SetSourceRGBA (double r, double g, double b, double a) { - NativeMethods.cairo_set_source_rgba (state, r, g, b, a); + NativeMethods.cairo_set_source_rgba (handle, r, g, b, a); } //[Obsolete ("Use SetSource method (with double parameters)")] public void SetSourceSurface (Surface source, int x, int y) { - NativeMethods.cairo_set_source_surface (state, source.Handle, x, y); + NativeMethods.cairo_set_source_surface (handle, source.Handle, x, y); } public void SetSource (Surface source, double x, double y) { - NativeMethods.cairo_set_source_surface (state, source.Handle, x, y); + NativeMethods.cairo_set_source_surface (handle, source.Handle, x, y); } public void SetSource (Surface source) { - NativeMethods.cairo_set_source_surface (state, source.Handle, 0, 0); + NativeMethods.cairo_set_source_surface (handle, source.Handle, 0, 0); } - + #region Path methods - - public void NewPath () - { - NativeMethods.cairo_new_path (state); - } + + public void NewPath () + { + NativeMethods.cairo_new_path (handle); + } public void NewSubPath () { - NativeMethods.cairo_new_sub_path (state); + NativeMethods.cairo_new_sub_path (handle); } - - public void MoveTo (PointD p) - { + + public void MoveTo (PointD p) + { MoveTo (p.X, p.Y); - } + } public void MoveTo (double x, double y) { - NativeMethods.cairo_move_to (state, x, y); + NativeMethods.cairo_move_to (handle, x, y); } - - public void LineTo (PointD p) + + public void LineTo (PointD p) { LineTo (p.X, p.Y); } - - public void LineTo (double x, double y) - { - NativeMethods.cairo_line_to (state, x, y); - } - public void CurveTo (PointD p1, PointD p2, PointD p3) + public void LineTo (double x, double y) + { + NativeMethods.cairo_line_to (handle, x, y); + } + + public void CurveTo (PointD p1, PointD p2, PointD p3) { CurveTo (p1.X, p1.Y, p2.X, p2.Y, p3.X, p3.Y); } - - public void CurveTo (double x1, double y1, double x2, double y2, double x3, double y3) - { - NativeMethods.cairo_curve_to (state, x1, y1, x2, y2, x3, y3); - } - public void RelMoveTo (Distance d) + public void CurveTo (double x1, double y1, double x2, double y2, double x3, double y3) + { + NativeMethods.cairo_curve_to (handle, x1, y1, x2, y2, x3, y3); + } + + public void RelMoveTo (Distance d) { RelMoveTo (d.Dx, d.Dy); } - - public void RelMoveTo (double dx, double dy) - { - NativeMethods.cairo_rel_move_to (state, dx, dy); - } - - public void RelLineTo (Distance d) - { - RelLineTo (d.Dx, d.Dy); - } - - public void RelLineTo (double dx, double dy) + + public void RelMoveTo (double dx, double dy) { - NativeMethods.cairo_rel_line_to (state, dx, dy); + NativeMethods.cairo_rel_move_to (handle, dx, dy); } - - public void RelCurveTo (Distance d1, Distance d2, Distance d3) + + public void RelLineTo (Distance d) + { + RelLineTo (d.Dx, d.Dy); + } + + public void RelLineTo (double dx, double dy) + { + NativeMethods.cairo_rel_line_to (handle, dx, dy); + } + + public void RelCurveTo (Distance d1, Distance d2, Distance d3) { RelCurveTo (d1.Dx, d1.Dy, d2.Dx, d2.Dy, d3.Dx, d3.Dy); } - public void RelCurveTo (double dx1, double dy1, double dx2, double dy2, double dx3, double dy3) - { - NativeMethods.cairo_rel_curve_to (state, dx1, dy1, dx2, dy2, dx3, dy3); - } + public void RelCurveTo (double dx1, double dy1, double dx2, double dy2, double dx3, double dy3) + { + NativeMethods.cairo_rel_curve_to (handle, dx1, dy1, dx2, dy2, dx3, dy3); + } - public void Arc (double xc, double yc, double radius, double angle1, double angle2) - { - NativeMethods.cairo_arc (state, xc, yc, radius, angle1, angle2); - } + public void Arc (double xc, double yc, double radius, double angle1, double angle2) + { + NativeMethods.cairo_arc (handle, xc, yc, radius, angle1, angle2); + } - public void ArcNegative (double xc, double yc, double radius, double angle1, double angle2) - { - NativeMethods.cairo_arc_negative (state, xc, yc, radius, angle1, angle2); - } - - public void Rectangle (Rectangle rectangle) + public void ArcNegative (double xc, double yc, double radius, double angle1, double angle2) + { + NativeMethods.cairo_arc_negative (handle, xc, yc, radius, angle1, angle2); + } + + public void Rectangle (Rectangle rectangle) { Rectangle (rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height); } - public void Rectangle (PointD p, double width, double height) + public void Rectangle (PointD p, double width, double height) { Rectangle (p.X, p.Y, width, height); } - public void Rectangle (double x, double y, double width, double height) - { - NativeMethods.cairo_rectangle (state, x, y, width, height); - } - - public void ClosePath () - { - NativeMethods.cairo_close_path (state); - } - - public Path CopyPath () + public void Rectangle (double x, double y, double width, double height) { - return new Path (NativeMethods.cairo_copy_path (state)); + NativeMethods.cairo_rectangle (handle, x, y, width, height); + } + + public void ClosePath () + { + NativeMethods.cairo_close_path (handle); + } + + public Path CopyPath () + { + return new Path (NativeMethods.cairo_copy_path (handle)); } public Path CopyPathFlat () { - return new Path (NativeMethods.cairo_copy_path_flat (state)); + return new Path (NativeMethods.cairo_copy_path_flat (handle)); } public void AppendPath (Path path) { - NativeMethods.cairo_append_path (state, path.handle); + NativeMethods.cairo_append_path (handle, path.Handle); } - + public void PathExtents (out double x1, out double y1, out double x2, out double y2) { - NativeMethods.cairo_path_extents (state, out x1, out y1, out x2, out y2); + NativeMethods.cairo_path_extents (handle, out x1, out y1, out x2, out y2); } #endregion @@ -587,206 +593,203 @@ namespace Cairo { #region Painting Methods public void Paint () { - NativeMethods.cairo_paint (state); + NativeMethods.cairo_paint (handle); } - + public void PaintWithAlpha (double alpha) { - NativeMethods.cairo_paint_with_alpha (state, alpha); + NativeMethods.cairo_paint_with_alpha (handle, alpha); } - + public void Mask (Pattern pattern) { - NativeMethods.cairo_mask (state, pattern.Handle); + NativeMethods.cairo_mask (handle, pattern.Handle); } - + public void MaskSurface (Surface surface, double surface_x, double surface_y) { - NativeMethods.cairo_mask_surface (state, surface.Handle, surface_x, surface_y); + NativeMethods.cairo_mask_surface (handle, surface.Handle, surface_x, surface_y); } - - public void Stroke () - { - NativeMethods.cairo_stroke (state); - } - - public void StrokePreserve () - { - NativeMethods.cairo_stroke_preserve (state); - } + + public void Stroke () + { + NativeMethods.cairo_stroke (handle); + } + + public void StrokePreserve () + { + NativeMethods.cairo_stroke_preserve (handle); + } public Rectangle StrokeExtents () { double x1, y1, x2, y2; - NativeMethods.cairo_stroke_extents (state, out x1, out y1, out x2, out y2); + NativeMethods.cairo_stroke_extents (handle, out x1, out y1, out x2, out y2); return new Rectangle (x1, y1, x2 - x1, y2 - y1); } - public void Fill () - { - NativeMethods.cairo_fill (state); - } + public void Fill () + { + NativeMethods.cairo_fill (handle); + } - public Rectangle FillExtents () + public Rectangle FillExtents () { double x1, y1, x2, y2; - NativeMethods.cairo_fill_extents (state, out x1, out y1, out x2, out y2); + NativeMethods.cairo_fill_extents (handle, out x1, out y1, out x2, out y2); return new Rectangle (x1, y1, x2 - x1, y2 - y1); } public void FillPreserve () { - NativeMethods.cairo_fill_preserve (state); + NativeMethods.cairo_fill_preserve (handle); } #endregion - public void Clip () - { - NativeMethods.cairo_clip (state); - } + public void Clip () + { + NativeMethods.cairo_clip (handle); + } public void ClipPreserve () { - NativeMethods.cairo_clip_preserve (state); + NativeMethods.cairo_clip_preserve (handle); } public void ResetClip () { - NativeMethods.cairo_reset_clip (state); + NativeMethods.cairo_reset_clip (handle); } public bool InStroke (double x, double y) { - return NativeMethods.cairo_in_stroke (state, x, y); + return NativeMethods.cairo_in_stroke (handle, x, y); } public bool InClip (double x, double y) { - return NativeMethods.cairo_in_clip (state, x, y); + return NativeMethods.cairo_in_clip (handle, x, y); } public bool InFill (double x, double y) { - return NativeMethods.cairo_in_fill (state, x, y); + return NativeMethods.cairo_in_fill (handle, x, y); } public Pattern PopGroup () { - return Pattern.Lookup (NativeMethods.cairo_pop_group (state)); + return Pattern.Lookup (NativeMethods.cairo_pop_group (handle), true); } public void PopGroupToSource () { - NativeMethods.cairo_pop_group_to_source (state); + NativeMethods.cairo_pop_group_to_source (handle); } public void PushGroup () { - NativeMethods.cairo_push_group (state); + NativeMethods.cairo_push_group (handle); } public void PushGroup (Content content) { - NativeMethods.cairo_push_group_with_content (state, content); + NativeMethods.cairo_push_group_with_content (handle, content); } public Surface GroupTarget { get { - IntPtr surface = NativeMethods.cairo_get_group_target (state); - return Surface.LookupSurface (surface); + IntPtr surface = NativeMethods.cairo_get_group_target (handle); + return Surface.Lookup (surface, false); } } - public void Rotate (double angle) - { - NativeMethods.cairo_rotate (state, angle); - } + public void Rotate (double angle) + { + NativeMethods.cairo_rotate (handle, angle); + } - public void Scale (double sx, double sy) - { - NativeMethods.cairo_scale (state, sx, sy); - } + public void Scale (double sx, double sy) + { + NativeMethods.cairo_scale (handle, sx, sy); + } + + public void Translate (double tx, double ty) + { + NativeMethods.cairo_translate (handle, tx, ty); + } - public void Translate (double tx, double ty) - { - NativeMethods.cairo_translate (state, tx, ty); - } - public void Transform (Matrix m) { - NativeMethods.cairo_transform (state, m); - } - -#region Methods that will become obsolete in the long term, after 1.2.5 becomes wildly available - - //[Obsolete("Use UserToDevice instead")] - public void TransformPoint (ref double x, ref double y) - { - NativeMethods.cairo_user_to_device (state, ref x, ref y); - } - - //[Obsolete("Use UserToDeviceDistance instead")] - public void TransformDistance (ref double dx, ref double dy) - { - NativeMethods.cairo_user_to_device_distance (state, ref dx, ref dy); - } - - //[Obsolete("Use InverseTransformPoint instead")] - public void InverseTransformPoint (ref double x, ref double y) - { - NativeMethods.cairo_device_to_user (state, ref x, ref y); + NativeMethods.cairo_transform (handle, m); } - //[Obsolete("Use DeviceToUserDistance instead")] + [Obsolete("Use UserToDevice instead")] + public void TransformPoint (ref double x, ref double y) + { + NativeMethods.cairo_user_to_device (handle, ref x, ref y); + } + + [Obsolete("Use UserToDeviceDistance instead")] + public void TransformDistance (ref double dx, ref double dy) + { + NativeMethods.cairo_user_to_device_distance (handle, ref dx, ref dy); + } + + [Obsolete("Use DeviceToUser instead")] + public void InverseTransformPoint (ref double x, ref double y) + { + NativeMethods.cairo_device_to_user (handle, ref x, ref y); + } + + [Obsolete("Use DeviceToUserDistance instead")] public void InverseTransformDistance (ref double dx, ref double dy) { - NativeMethods.cairo_device_to_user_distance (state, ref dx, ref dy); + NativeMethods.cairo_device_to_user_distance (handle, ref dx, ref dy); } -#endregion - + public void UserToDevice (ref double x, ref double y) { - NativeMethods.cairo_user_to_device (state, ref x, ref y); + NativeMethods.cairo_user_to_device (handle, ref x, ref y); } - - public void UserToDeviceDistance (ref double dx, ref double dy) + + public void UserToDeviceDistance (ref double dx, ref double dy) { - NativeMethods.cairo_user_to_device_distance (state, ref dx, ref dy); + NativeMethods.cairo_user_to_device_distance (handle, ref dx, ref dy); } - + public void DeviceToUser (ref double x, ref double y) { - NativeMethods.cairo_device_to_user (state, ref x, ref y); + NativeMethods.cairo_device_to_user (handle, ref x, ref y); } public void DeviceToUserDistance (ref double dx, ref double dy) { - NativeMethods.cairo_device_to_user_distance (state, ref dx, ref dy); + NativeMethods.cairo_device_to_user_distance (handle, ref dx, ref dy); } - - public Cairo.Matrix Matrix { - set { - NativeMethods.cairo_set_matrix (state, value); - } - get { - Matrix m = new Matrix(); - NativeMethods.cairo_get_matrix (state, m); - return m; - } - } + public Cairo.Matrix Matrix { + set { + NativeMethods.cairo_set_matrix (handle, value); + } + + get { + Matrix m = new Matrix (); + NativeMethods.cairo_get_matrix (handle, m); + return m; + } + } public void SetFontSize (double scale) { - NativeMethods.cairo_set_font_size (state, scale); + NativeMethods.cairo_set_font_size (handle, scale); } public void IdentityMatrix () { - NativeMethods.cairo_identity_matrix (state); + NativeMethods.cairo_identity_matrix (handle); } - + [Obsolete ("Use SetFontSize() instead.")] public void FontSetSize (double scale) { @@ -797,23 +800,23 @@ namespace Cairo { public double FontSize { set { SetFontSize (value); } } - + public Matrix FontMatrix { get { Matrix m; - NativeMethods.cairo_get_font_matrix (state, out m); + NativeMethods.cairo_get_font_matrix (handle, out m); return m; } - set { NativeMethods.cairo_set_font_matrix (state, value); } + set { NativeMethods.cairo_set_font_matrix (handle, value); } } public FontOptions FontOptions { get { FontOptions options = new FontOptions (); - NativeMethods.cairo_get_font_options (state, options.Handle); + NativeMethods.cairo_get_font_options (handle, options.Handle); return options; } - set { NativeMethods.cairo_set_font_options (state, value.Handle); } + set { NativeMethods.cairo_set_font_options (handle, value.Handle); } } [StructLayout(LayoutKind.Sequential)] @@ -843,7 +846,7 @@ namespace Cairo { } else { foreach (Glyph g in glyphs){ NativeGlyph_4byte_longs n = new NativeGlyph_4byte_longs (g); - + Marshal.StructureToPtr (n, (IntPtr)pos, false); pos += native_glyph_size; } @@ -852,52 +855,52 @@ namespace Cairo { return dest; } - public void ShowGlyphs (Glyph[] glyphs) + public void ShowGlyphs (Glyph[] glyphs) { - IntPtr ptr; + IntPtr ptr; - ptr = FromGlyphToUnManagedMemory (glyphs); - - NativeMethods.cairo_show_glyphs (state, ptr, glyphs.Length); + ptr = FromGlyphToUnManagedMemory (glyphs); - Marshal.FreeHGlobal (ptr); + NativeMethods.cairo_show_glyphs (handle, ptr, glyphs.Length); + + Marshal.FreeHGlobal (ptr); } [Obsolete("The matrix argument was never used, use ShowGlyphs(Glyphs []) instead")] - public void ShowGlyphs (Matrix matrix, Glyph[] glyphs) - { + public void ShowGlyphs (Matrix matrix, Glyph[] glyphs) + { ShowGlyphs (glyphs); - } + } [Obsolete("The matrix argument was never used, use GlyphPath(Glyphs []) instead")] - public void GlyphPath (Matrix matrix, Glyph[] glyphs) - { + public void GlyphPath (Matrix matrix, Glyph[] glyphs) + { GlyphPath (glyphs); } public void GlyphPath (Glyph[] glyphs) { - IntPtr ptr; + IntPtr ptr; - ptr = FromGlyphToUnManagedMemory (glyphs); + ptr = FromGlyphToUnManagedMemory (glyphs); - NativeMethods.cairo_glyph_path (state, ptr, glyphs.Length); + NativeMethods.cairo_glyph_path (handle, ptr, glyphs.Length); - Marshal.FreeHGlobal (ptr); + Marshal.FreeHGlobal (ptr); - } + } + + public FontExtents FontExtents { + get { + FontExtents f_extents; + NativeMethods.cairo_font_extents (handle, out f_extents); + return f_extents; + } + } - public FontExtents FontExtents { - get { - FontExtents f_extents; - NativeMethods.cairo_font_extents (state, out f_extents); - return f_extents; - } - } - public void CopyPage () { - NativeMethods.cairo_copy_page (state); + NativeMethods.cairo_copy_page (handle); } [Obsolete ("Use SelectFontFace() instead.")] @@ -908,38 +911,38 @@ namespace Cairo { public FontFace ContextFontFace { get { - return Cairo.FontFace.Lookup (NativeMethods.cairo_get_font_face (state)); + return Cairo.FontFace.Lookup (NativeMethods.cairo_get_font_face (handle), false); } set { - NativeMethods.cairo_set_font_face (state, value == null ? IntPtr.Zero : value.Handle); + NativeMethods.cairo_set_font_face (handle, value == null ? IntPtr.Zero : value.Handle); } } public void SelectFontFace (string family, FontSlant slant, FontWeight weight) { - NativeMethods.cairo_select_font_face (state, family, slant, weight); + NativeMethods.cairo_select_font_face (handle, family, slant, weight); } public void ShowPage () { - NativeMethods.cairo_show_page (state); + NativeMethods.cairo_show_page (handle); + } + + public void ShowText (string str) + { + NativeMethods.cairo_show_text (handle, str); + } + + public void TextPath (string str) + { + NativeMethods.cairo_text_path (handle, str); } - - public void ShowText (string str) - { - NativeMethods.cairo_show_text (state, str); - } - - public void TextPath (string str) - { - NativeMethods.cairo_text_path (state, str); - } public TextExtents TextExtents (string utf8) { TextExtents extents; - NativeMethods.cairo_text_extents (state, utf8, out extents); + NativeMethods.cairo_text_extents (handle, utf8, out extents); return extents; } @@ -949,7 +952,7 @@ namespace Cairo { TextExtents extents; - NativeMethods.cairo_glyph_extents (state, ptr, glyphs.Length, out extents); + NativeMethods.cairo_glyph_extents (handle, ptr, glyphs.Length, out extents); Marshal.FreeHGlobal (ptr); @@ -960,5 +963,5 @@ namespace Cairo { { return NativeMethods.cairo_format_stride_for_width (format, width); } - } + } } diff --git a/cairo/DirectFBSurface.cs b/cairo/DirectFBSurface.cs index a2ae169e7..afa57b7df 100644 --- a/cairo/DirectFBSurface.cs +++ b/cairo/DirectFBSurface.cs @@ -36,11 +36,8 @@ namespace Cairo { } public DirectFBSurface (IntPtr dfb, IntPtr dfb_surface) + : base (NativeMethods.cairo_directfb_surface_create (dfb, dfb_surface), true) { - surface = NativeMethods.cairo_directfb_surface_create (dfb, dfb_surface); - lock (surfaces.SyncRoot) { - surfaces [surface] = this; - } } } } diff --git a/cairo/FontFace.cs b/cairo/FontFace.cs index ca1de265c..19d8163c3 100644 --- a/cairo/FontFace.cs +++ b/cairo/FontFace.cs @@ -38,14 +38,11 @@ namespace Cairo { IntPtr handle; - internal static FontFace Lookup (IntPtr handle) + internal static FontFace Lookup (IntPtr handle, bool owner) { if (handle == IntPtr.Zero) return null; - - NativeMethods.cairo_font_face_reference (handle); - - return new FontFace (handle); + return new FontFace (handle, owner); } ~FontFace () @@ -70,11 +67,17 @@ namespace Cairo NativeMethods.cairo_font_face_destroy (handle); handle = IntPtr.Zero; } - - // TODO: make non-public when all entry points are complete in binding - public FontFace (IntPtr handle) + + [Obsolete] + public FontFace (IntPtr handle) : this (handle, true) + { + } + + public FontFace (IntPtr handle, bool owned) { this.handle = handle; + if (!owned) + NativeMethods.cairo_font_face_reference (handle); if (CairoDebug.Enabled) CairoDebug.OnAllocated (handle); } diff --git a/cairo/FontOptions.cs b/cairo/FontOptions.cs index c0583f10c..e67703075 100644 --- a/cairo/FontOptions.cs +++ b/cairo/FontOptions.cs @@ -34,9 +34,8 @@ namespace Cairo { IntPtr handle; - public FontOptions () + public FontOptions () : this (NativeMethods.cairo_font_options_create ()) { - handle = NativeMethods.cairo_font_options_create (); } ~FontOptions () @@ -59,7 +58,7 @@ namespace Cairo [Obsolete ("Use Dispose()")] public void Destroy () { - Dispose (); + NativeMethods.cairo_font_options_destroy (handle); } public void Dispose () diff --git a/cairo/GlitzSurface.cs b/cairo/GlitzSurface.cs index a8cd700a5..6da1ac6a9 100644 --- a/cairo/GlitzSurface.cs +++ b/cairo/GlitzSurface.cs @@ -36,11 +36,8 @@ namespace Cairo { } public GlitzSurface (IntPtr glitz_surface) + : base (NativeMethods.cairo_glitz_surface_create (glitz_surface), true) { - surface = NativeMethods.cairo_glitz_surface_create (glitz_surface); - lock (surfaces.SyncRoot) { - surfaces [surface] = this; - } } } } diff --git a/cairo/Gradient.cs b/cairo/Gradient.cs index c15980b07..0fb617e42 100644 --- a/cairo/Gradient.cs +++ b/cairo/Gradient.cs @@ -1,4 +1,4 @@ -// +// // Mono.Cairo.Gradient.cs // // Author: Jordi Mas (jordi@ximian.com) @@ -14,10 +14,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 @@ -30,13 +30,14 @@ using System; namespace Cairo { - + public class Gradient : Pattern { - protected Gradient (IntPtr handle) : base (handle) + protected Gradient (IntPtr handle, bool owned) : base (handle, owned) { } + [Obsolete] protected Gradient () { } @@ -44,20 +45,20 @@ namespace Cairo { public int ColorStopCount { get { int cnt; - NativeMethods.cairo_pattern_get_color_stop_count (pattern, out cnt); + NativeMethods.cairo_pattern_get_color_stop_count (Handle, out cnt); return cnt; } } - public Status AddColorStop (double offset, Cairo.Color c) + public Status AddColorStop (double offset, Color c) { - NativeMethods.cairo_pattern_add_color_stop_rgba (pattern, offset, c.R, c.G, c.B, c.A); + NativeMethods.cairo_pattern_add_color_stop_rgba (Handle, offset, c.R, c.G, c.B, c.A); return Status; } - public Status AddColorStopRgb (double offset, Cairo.Color c) + public Status AddColorStopRgb (double offset, Color c) { - NativeMethods.cairo_pattern_add_color_stop_rgb (pattern, offset, c.R, c.G, c.B); + NativeMethods.cairo_pattern_add_color_stop_rgb (Handle, offset, c.R, c.G, c.B); return Status; } } diff --git a/cairo/ImageSurface.cs b/cairo/ImageSurface.cs index 659833a7c..98143fe8e 100644 --- a/cairo/ImageSurface.cs +++ b/cairo/ImageSurface.cs @@ -19,10 +19,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 @@ -37,60 +37,49 @@ using System.Runtime.InteropServices; namespace Cairo { - public class ImageSurface : Surface - { + public class ImageSurface : Surface + { internal ImageSurface (IntPtr handle, bool owns) : base (handle, owns) { } public ImageSurface (Format format, int width, int height) + : base (NativeMethods.cairo_image_surface_create (format, width, height), true) { - surface = NativeMethods.cairo_image_surface_create (format, width, height); - lock (surfaces.SyncRoot){ - surfaces [surface] = this; - } } - + [Obsolete ("Use ImageSurface (byte[] data, Cairo.Format format, int width, int height, int stride)")] - public ImageSurface (ref byte[] data, Cairo.Format format, int width, int height, int stride) :this (data, format, width, height, stride) + public ImageSurface (ref byte[] data, Cairo.Format format, int width, int height, int stride) + : this (data, format, width, height, stride) { } - public ImageSurface (byte[] data, Cairo.Format format, int width, int height, int stride) + public ImageSurface (byte[] data, Format format, int width, int height, int stride) + : base (NativeMethods.cairo_image_surface_create_for_data (data, format, width, height, stride), true) { - surface = NativeMethods.cairo_image_surface_create_for_data (data, format, width, height, stride); - lock (surfaces.SyncRoot){ - surfaces [surface] = this; - } } - public ImageSurface (IntPtr data, Cairo.Format format, int width, int height, int stride) + public ImageSurface (IntPtr data, Format format, int width, int height, int stride) + : base (NativeMethods.cairo_image_surface_create_for_data (data, format, width, height, stride), true) { - surface = NativeMethods.cairo_image_surface_create_for_data (data, format, width, height, stride); - lock (surfaces.SyncRoot){ - surfaces [surface] = this; - } } - + public ImageSurface (string filename) + : base (NativeMethods.cairo_image_surface_create_from_png (filename), true) { - surface = NativeMethods.cairo_image_surface_create_from_png (filename); - lock (surfaces.SyncRoot){ - surfaces [surface] = this; - } } - + public int Width { - get { return NativeMethods.cairo_image_surface_get_width (surface); } + get { return NativeMethods.cairo_image_surface_get_width (Handle); } } - + public int Height { - get { return NativeMethods.cairo_image_surface_get_height (surface); } + get { return NativeMethods.cairo_image_surface_get_height (Handle); } } - + public byte[] Data { get { - IntPtr ptr = NativeMethods.cairo_image_surface_get_data (surface); + IntPtr ptr = NativeMethods.cairo_image_surface_get_data (Handle); int length = Height * Stride; byte[] data = new byte[length]; Marshal.Copy (ptr, data, 0, length); @@ -100,16 +89,16 @@ namespace Cairo { public IntPtr DataPtr { get { - return NativeMethods.cairo_image_surface_get_data (surface); + return NativeMethods.cairo_image_surface_get_data (Handle); } } public Format Format { - get { return NativeMethods.cairo_image_surface_get_format (surface); } + get { return NativeMethods.cairo_image_surface_get_format (Handle); } } public int Stride { - get { return NativeMethods.cairo_image_surface_get_stride (surface); } + get { return NativeMethods.cairo_image_surface_get_stride (Handle); } } } } diff --git a/cairo/LinearGradient.cs b/cairo/LinearGradient.cs index 58d8e21ab..85fdea84a 100644 --- a/cairo/LinearGradient.cs +++ b/cairo/LinearGradient.cs @@ -1,4 +1,4 @@ -// +// // Mono.Cairo.LinearGradient.cs // // Author: Jordi Mas (jordi@ximian.com) @@ -14,10 +14,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 @@ -30,31 +30,30 @@ using System; namespace Cairo { - + public class LinearGradient : Gradient { - internal LinearGradient (IntPtr handle) : base (handle) + internal LinearGradient (IntPtr handle, bool owned) : base (handle, owned) { } public LinearGradient (double x0, double y0, double x1, double y1) + : base (NativeMethods.cairo_pattern_create_linear (x0, y0, x1, y1), true) { - pattern = NativeMethods.cairo_pattern_create_linear (x0, y0, x1, y1); } public PointD[] LinearPoints { - get { + get { double x0, y0, x1, y1; PointD[] points = new PointD [2]; - NativeMethods.cairo_pattern_get_linear_points (pattern, out x0, out y0, out x1, out y1); + NativeMethods.cairo_pattern_get_linear_points (Handle, out x0, out y0, out x1, out y1); points[0] = new PointD (x0, y0); points[1] = new PointD (x1, y1); return points; - } - } - + } + } } } diff --git a/cairo/Matrix.cs b/cairo/Matrix.cs index 79e1f359e..83ffce49d 100644 --- a/cairo/Matrix.cs +++ b/cairo/Matrix.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 @@ -36,110 +36,110 @@ using System.Runtime.InteropServices; namespace Cairo { - [StructLayout(LayoutKind.Sequential)] - public class Matrix : ICloneable - { + [StructLayout(LayoutKind.Sequential)] + public class Matrix : ICloneable + { public double Xx; public double Yx; - public double Xy; + public double Xy; public double Yy; - public double X0; + public double X0; public double Y0; public Matrix (double xx, double yx, double xy, double yy, double x0, double y0) - { + { this.Xx = xx; this.Yx = yx; this.Xy = xy; this.Yy = yy; this.X0 = x0; this.Y0 = y0; } - - public Matrix () + + public Matrix () { this.InitIdentity (); } - + public bool IsIdentity () { return (this == new Matrix ()); } - - public void InitIdentity () - { - // this.Init(1,0,0,1,0,0); - NativeMethods.cairo_matrix_init_identity (this); - } - + + public void InitIdentity () + { + // this.Init(1,0,0,1,0,0); + NativeMethods.cairo_matrix_init_identity (this); + } + public void Init (double xx, double yx, double xy, double yy, double x0, double y0) { this.Xx = xx; this.Yx = yx; this.Xy = xy; this.Yy = yy; this.X0 = x0; this.Y0 = y0; } - + public void InitTranslate (double tx, double ty) - { + { //this.Init (1, 0, 0, 1, tx, ty); NativeMethods.cairo_matrix_init_translate (this, tx, ty); - } - + } + public void Translate (double tx, double ty) { NativeMethods.cairo_matrix_translate (this, tx, ty); } - - public void InitScale (double sx, double sy) - { + + public void InitScale (double sx, double sy) + { //this.Init (sx, 0, 0, sy, 0, 0); - NativeMethods.cairo_matrix_init_scale (this, sx, sy); - } - - public void Scale (double sx, double sy) - { + NativeMethods.cairo_matrix_init_scale (this, sx, sy); + } + + public void Scale (double sx, double sy) + { NativeMethods.cairo_matrix_scale (this, sx, sy); - } + } - public void InitRotate (double radians) - { - /* - double s, c; - s = Math.Sin (radians); - c = Math.Cos (radians); - this.Init (c, s, -s, c, 0, 0); - */ - NativeMethods.cairo_matrix_init_rotate (this, radians); - } - - public void Rotate (double radians) - { + public void InitRotate (double radians) + { + /* + double s, c; + s = Math.Sin (radians); + c = Math.Cos (radians); + this.Init (c, s, -s, c, 0, 0); + */ + NativeMethods.cairo_matrix_init_rotate (this, radians); + } + + public void Rotate (double radians) + { NativeMethods.cairo_matrix_rotate (this, radians); - } + } - public Cairo.Status Invert () - { + public Cairo.Status Invert () + { return NativeMethods.cairo_matrix_invert (this); - } + } public void Multiply (Matrix b) { Matrix a = (Matrix) this.Clone (); NativeMethods.cairo_matrix_multiply (this, a, b); } - + public static Matrix Multiply (Matrix a, Matrix b) { Matrix result = new Matrix (); NativeMethods.cairo_matrix_multiply (result, a, b); return result; } - - - public void TransformDistance (ref double dx, ref double dy) - { - NativeMethods.cairo_matrix_transform_distance (this, ref dx, ref dy); - } - public void TransformPoint (ref double x, ref double y) - { - NativeMethods.cairo_matrix_transform_point (this, ref x, ref y); + + public void TransformDistance (ref double dx, ref double dy) + { + NativeMethods.cairo_matrix_transform_distance (this, ref dx, ref dy); + } + + public void TransformPoint (ref double x, ref double y) + { + NativeMethods.cairo_matrix_transform_point (this, ref x, ref y); } public override String ToString () @@ -148,7 +148,7 @@ namespace Cairo { this.Xx, this.Yx, this.Xy, this.Yy, this.X0, this.Y0); return s; } - + public static bool operator == (Matrix lhs, Matrix rhs) { return (lhs.Xx == rhs.Xx && @@ -158,14 +158,14 @@ namespace Cairo { lhs.X0 == rhs.X0 && lhs.Y0 == rhs.Y0 ); } - + public static bool operator != (Matrix lhs, Matrix rhs) { - return !(lhs==rhs); + return !(lhs==rhs); } - - - + + + public override bool Equals(object o) { if (! (o is Matrix)) @@ -173,7 +173,7 @@ namespace Cairo { else return (this == (Matrix) o); } - + public override int GetHashCode() { return (int)this.Xx ^ (int)this.Xx>>32 ^ @@ -183,11 +183,11 @@ namespace Cairo { (int)this.X0 ^ (int)this.X0>>32 ^ (int)this.Y0 ^ (int)this.Y0>>32; } - + public object Clone() { return this.MemberwiseClone (); } - - } + + } } diff --git a/cairo/PSSurface.cs b/cairo/PSSurface.cs index 87d1f11b2..9d6b73be6 100644 --- a/cairo/PSSurface.cs +++ b/cairo/PSSurface.cs @@ -37,31 +37,28 @@ namespace Cairo { } public PSSurface (string filename, double width, double height) + : base (NativeMethods.cairo_ps_surface_create (filename, width, height), true) { - surface = NativeMethods.cairo_ps_surface_create (filename, width, height); - lock (surfaces.SyncRoot){ - surfaces [surface] = this; - } } public void BeginPageSetup () { - NativeMethods.cairo_ps_surface_dsc_begin_page_setup (surface); + NativeMethods.cairo_ps_surface_dsc_begin_page_setup (Handle); } public void BeginSetup () { - NativeMethods.cairo_ps_surface_dsc_begin_setup (surface); + NativeMethods.cairo_ps_surface_dsc_begin_setup (Handle); } public void DscComment (string comment) { - NativeMethods.cairo_ps_surface_dsc_comment (surface, comment); + NativeMethods.cairo_ps_surface_dsc_comment (Handle, comment); } public void SetSize (double width, double height) { - NativeMethods.cairo_ps_surface_set_size (surface, width, height); + NativeMethods.cairo_ps_surface_set_size (Handle, width, height); } } } diff --git a/cairo/Path.cs b/cairo/Path.cs index 45c9557ca..3844c801f 100644 --- a/cairo/Path.cs +++ b/cairo/Path.cs @@ -15,10 +15,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 @@ -34,10 +34,10 @@ using Cairo; namespace Cairo { - public class Path : IDisposable - { - internal IntPtr handle = IntPtr.Zero; - + public class Path : IDisposable + { + IntPtr handle = IntPtr.Zero; + internal Path (IntPtr handle) { this.handle = handle; @@ -50,7 +50,8 @@ namespace Cairo { Dispose (false); } - + public IntPtr Handle { get { return handle; } } + public void Dispose () { Dispose (true); @@ -61,8 +62,8 @@ namespace Cairo { { if (!disposing || CairoDebug.Enabled) CairoDebug.OnDisposed (handle, disposing); - - if (!disposing|| handle == IntPtr.Zero) + + if (!disposing || handle == IntPtr.Zero) return; NativeMethods.cairo_path_destroy (handle); diff --git a/cairo/Pattern.cs b/cairo/Pattern.cs index be9c49214..bc0a962a2 100644 --- a/cairo/Pattern.cs +++ b/cairo/Pattern.cs @@ -1,4 +1,4 @@ -// +// // Mono.Cairo.Pattern.cs // // Author: Jordi Mas (jordi@ximian.com) @@ -32,47 +32,41 @@ using System.Collections; namespace Cairo { - public class Pattern : IDisposable - { + public class Pattern : IDisposable + { + [Obsolete] protected IntPtr pattern = IntPtr.Zero; - public static Pattern Lookup (IntPtr pattern) + public static Pattern Lookup (IntPtr pattern, bool owner) { if (pattern == IntPtr.Zero) return null; - - object x = patterns [pattern]; - if (x != null) - return (Pattern) x; PatternType pt = NativeMethods.cairo_pattern_get_type (pattern); switch (pt) { case PatternType.Solid: - return new SolidPattern (pattern); + return new SolidPattern (pattern, owner); case PatternType.Surface: - return new SurfacePattern (pattern); + return new SurfacePattern (pattern, owner); case PatternType.Linear: - return new LinearGradient (pattern); + return new LinearGradient (pattern, owner); case PatternType.Radial: - return new RadialGradient (pattern); + return new RadialGradient (pattern, owner); default: - return new Pattern (pattern); + return new Pattern (pattern, owner); } } - - protected Pattern () - { - } - static Hashtable patterns = new Hashtable (); - - internal Pattern (IntPtr handle) + [Obsolete] + protected Pattern () + { + } + + internal Pattern (IntPtr handle, bool owned) { - lock (patterns){ - patterns [handle] = this; - } - Handle = handle; + if (!owned) + NativeMethods.cairo_pattern_reference (handle); if (CairoDebug.Enabled) CairoDebug.OnAllocated (handle); } @@ -82,16 +76,17 @@ namespace Cairo { Dispose (false); } - [Obsolete ("Use the SurfacePattern constructor")] - public Pattern (Surface surface) - { - pattern = NativeMethods.cairo_pattern_create_for_surface (surface.Handle); - } + [Obsolete ("Use the SurfacePattern constructor")] + public Pattern (Surface surface) + : this ( NativeMethods.cairo_pattern_create_for_surface (surface.Handle), true) + { + } - protected void Reference () - { - NativeMethods.cairo_pattern_reference (pattern); - } + [Obsolete] + protected void Reference () + { + NativeMethods.cairo_pattern_reference (pattern); + } public void Dispose () { @@ -109,52 +104,52 @@ namespace Cairo { NativeMethods.cairo_pattern_destroy (Handle); Handle = IntPtr.Zero; - lock (patterns){ - patterns.Remove (this); - } } [Obsolete ("Use Dispose()")] - public void Destroy () - { - NativeMethods.cairo_pattern_destroy (pattern); - } - - public Extend Extend { - get { return NativeMethods.cairo_pattern_get_extend (pattern); } - set { NativeMethods.cairo_pattern_set_extend (pattern, value); } + public void Destroy () + { + Dispose (); } public Status Status { - get { return NativeMethods.cairo_pattern_status (pattern); } + get { return NativeMethods.cairo_pattern_status (Handle); } } - - public Matrix Matrix { - set { - NativeMethods.cairo_pattern_set_matrix (pattern, value); + + public Extend Extend + { + get { return NativeMethods.cairo_pattern_get_extend (Handle); } + set { NativeMethods.cairo_pattern_set_extend (Handle, value); } + } + + public Matrix Matrix { + set { + NativeMethods.cairo_pattern_set_matrix (Handle, value); } - get { + get { Matrix m = new Matrix (); - NativeMethods.cairo_pattern_get_matrix (pattern, m); + NativeMethods.cairo_pattern_get_matrix (Handle, m); return m; - } - } + } + } - public IntPtr Handle { - get { return pattern; } - private set { pattern = value; } - } +#pragma warning disable 612 + public IntPtr Handle { + get { return pattern; } + private set { pattern = value; } + } +#pragma warning restore 612 - [Obsolete ("Replaced by Handle property")] - public IntPtr Pointer { - get { return Handle; } - } + [Obsolete] + public IntPtr Pointer { + get { return pattern; } + } public PatternType PatternType { - get { return NativeMethods.cairo_pattern_get_type (pattern); } + get { return NativeMethods.cairo_pattern_get_type (Handle); } } - } + } } diff --git a/cairo/PdfSurface.cs b/cairo/PdfSurface.cs index f3a184bb5..c980f249e 100644 --- a/cairo/PdfSurface.cs +++ b/cairo/PdfSurface.cs @@ -37,16 +37,13 @@ namespace Cairo { } public PdfSurface (string filename, double width, double height) + : base (NativeMethods.cairo_pdf_surface_create (filename, width, height), true) { - surface = NativeMethods.cairo_pdf_surface_create (filename, width, height); - lock (surfaces.SyncRoot){ - surfaces [surface] = this; - } } public void SetSize (double width, double height) { - NativeMethods.cairo_pdf_surface_set_size (surface, width, height); + NativeMethods.cairo_pdf_surface_set_size (Handle, width, height); } } } diff --git a/cairo/RadialGradient.cs b/cairo/RadialGradient.cs index df9c32905..6422e00d6 100644 --- a/cairo/RadialGradient.cs +++ b/cairo/RadialGradient.cs @@ -1,4 +1,4 @@ -// +// // Mono.Cairo.Pattern.cs // // Author: Jordi Mas (jordi@ximian.com) @@ -14,10 +14,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 @@ -30,16 +30,16 @@ using System; namespace Cairo { - + public class RadialGradient : Gradient { - internal RadialGradient (IntPtr handle) : base (handle) + internal RadialGradient (IntPtr handle, bool owned) : base (handle, owned) { } public RadialGradient (double cx0, double cy0, double radius0, double cx1, double cy1, double radius1) + : base (NativeMethods.cairo_pattern_create_radial (cx0, cy0, radius0, cx1, cy1, radius1), true) { - pattern = NativeMethods.cairo_pattern_create_radial (cx0, cy0, radius0, cx1, cy1, radius1); } } } diff --git a/cairo/ScaledFont.cs b/cairo/ScaledFont.cs index 27a875db1..937194607 100644 --- a/cairo/ScaledFont.cs +++ b/cairo/ScaledFont.cs @@ -32,15 +32,17 @@ namespace Cairo { { protected IntPtr handle = IntPtr.Zero; - internal ScaledFont (IntPtr handle) + internal ScaledFont (IntPtr handle, bool owner) { this.handle = handle; + if (!owner) + NativeMethods.cairo_scaled_font_reference (handle); if (CairoDebug.Enabled) CairoDebug.OnAllocated (handle); } public ScaledFont (FontFace fontFace, Matrix matrix, Matrix ctm, FontOptions options) - : this (NativeMethods.cairo_scaled_font_create (fontFace.Handle, matrix, ctm, options.Handle)) + : this (NativeMethods.cairo_scaled_font_create (fontFace.Handle, matrix, ctm, options.Handle), true) { } @@ -49,19 +51,19 @@ namespace Cairo { Dispose (false); } - public IntPtr Handle { - get { - return handle; - } - } + public IntPtr Handle { + get { + return handle; + } + } public FontExtents FontExtents { - get { - FontExtents extents; - NativeMethods.cairo_scaled_font_extents (handle, out extents); - return extents; - } - } + get { + FontExtents extents; + NativeMethods.cairo_scaled_font_extents (handle, out extents); + return extents; + } + } public Matrix FontMatrix { get { @@ -110,11 +112,12 @@ namespace Cairo { NativeMethods.cairo_scaled_font_destroy (handle); handle = IntPtr.Zero; } - - protected void Reference () - { - NativeMethods.cairo_scaled_font_reference (handle); - } + + [Obsolete] + protected void Reference () + { + NativeMethods.cairo_scaled_font_reference (handle); + } } } diff --git a/cairo/SolidPattern.cs b/cairo/SolidPattern.cs index 44dba86a9..875b3fbf1 100644 --- a/cairo/SolidPattern.cs +++ b/cairo/SolidPattern.cs @@ -1,4 +1,4 @@ -// +// // Mono.Cairo.Pattern.cs // // Author: Jordi Mas (jordi@ximian.com) @@ -14,10 +14,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 @@ -30,44 +30,43 @@ using System; namespace Cairo { - + public class SolidPattern : Pattern { - internal SolidPattern (IntPtr handle) : base (handle) + internal SolidPattern (IntPtr handle, bool owned) : base (handle, owned) { } public SolidPattern (Color color) + : base (NativeMethods.cairo_pattern_create_rgba (color.R, color.G, color.B, color.A), true) { - pattern = NativeMethods.cairo_pattern_create_rgba (color.R, color.G, color.B, color.A); } public SolidPattern (double r, double g, double b) + : base (NativeMethods.cairo_pattern_create_rgb (r, g, b), true) { - pattern = NativeMethods.cairo_pattern_create_rgb (r, g, b); } public SolidPattern (double r, double g, double b, double a) + : base (NativeMethods.cairo_pattern_create_rgba (r, g, b, a), true) { - NativeMethods.cairo_pattern_create_rgba (r, g, b, a); } public SolidPattern (Color color, bool solid) + : base (solid + ? NativeMethods.cairo_pattern_create_rgb (color.R, color.G, color.B) + : NativeMethods.cairo_pattern_create_rgba (color.R, color.G, color.B, color.A), + true) { - if (solid) - pattern = NativeMethods.cairo_pattern_create_rgb (color.R, color.G, color.B); - else - pattern = NativeMethods.cairo_pattern_create_rgba (color.R, color.G, color.B, color.A); } public Color Color { - get { + get { double red, green, blue, alpha; - - NativeMethods.cairo_pattern_get_rgba (pattern, out red, out green, out blue, out alpha); + NativeMethods.cairo_pattern_get_rgba (Handle, out red, out green, out blue, out alpha); return new Color (red, green, blue, alpha); - } - } + } + } } } diff --git a/cairo/Surface.cs b/cairo/Surface.cs index 52a4aee83..6fa8c0209 100644 --- a/cairo/Surface.cs +++ b/cairo/Surface.cs @@ -20,10 +20,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 @@ -38,97 +38,88 @@ using System.Collections; namespace Cairo { - public class Surface : IDisposable - { + public class Surface : IDisposable + { + [Obsolete] protected static Hashtable surfaces = new Hashtable (); - internal IntPtr surface = IntPtr.Zero; + + IntPtr handle = IntPtr.Zero; [Obsolete] protected Surface() { } - - protected Surface (IntPtr ptr, bool owns) - { - surface = ptr; - lock (surfaces.SyncRoot){ - surfaces [ptr] = this; - } - if (!owns) - NativeMethods.cairo_surface_reference (ptr); - if (CairoDebug.Enabled) - CairoDebug.OnAllocated (ptr); - } - static internal Surface LookupExternalSurface (IntPtr p) + [Obsolete] + protected Surface (IntPtr ptr) : this (ptr, true) { - lock (surfaces.SyncRoot){ - object o = surfaces [p]; - if (o == null){ - return new Surface (p, false); - } - return (Surface) o; - } - } + } - public static Surface LookupSurface (IntPtr surface) + protected Surface (IntPtr handle, bool owner) + { + this.handle = handle; + if (!owner) + NativeMethods.cairo_surface_reference (handle); + if (CairoDebug.Enabled) + CairoDebug.OnAllocated (handle); + } + + public static Surface Lookup (IntPtr surface, bool owned) { SurfaceType st = NativeMethods.cairo_surface_get_type (surface); switch (st) { case SurfaceType.Image: - return new ImageSurface (surface, true); + return new ImageSurface (surface, owned); case SurfaceType.Xlib: - return new XlibSurface (surface, true); + return new XlibSurface (surface, owned); case SurfaceType.Xcb: - return new XcbSurface (surface, true); + return new XcbSurface (surface, owned); case SurfaceType.Glitz: - return new GlitzSurface (surface, true); + return new GlitzSurface (surface, owned); case SurfaceType.Win32: - return new Win32Surface (surface, true); - + return new Win32Surface (surface, owned); case SurfaceType.Pdf: - return new PdfSurface (surface, true); + return new PdfSurface (surface, owned); case SurfaceType.PS: - return new PSSurface (surface, true); + return new PSSurface (surface, owned); case SurfaceType.DirectFB: - return new DirectFBSurface (surface, true); + return new DirectFBSurface (surface, owned); case SurfaceType.Svg: - return new SvgSurface (surface, true); - + return new SvgSurface (surface, owned); default: - return Surface.LookupExternalSurface (surface); + return new Surface (surface, owned); } } - - [Obsolete ("Use an ImageSurface constructor instead.")] - public static Cairo.Surface CreateForImage ( - ref byte[] data, Cairo.Format format, int width, int height, int stride) - { - IntPtr p = NativeMethods.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) - { - IntPtr p = NativeMethods.cairo_image_surface_create ( - format, width, height); + public static Cairo.Surface CreateForImage ( + ref byte[] data, Cairo.Format format, int width, int height, int stride) + { + IntPtr p = NativeMethods.cairo_image_surface_create_for_data ( + data, format, width, height, stride); - return new Cairo.Surface (p, true); - } + return new Cairo.Surface (p, true); + } + + [Obsolete ("Use an ImageSurface constructor instead.")] + public static Cairo.Surface CreateForImage ( + Cairo.Format format, int width, int height) + { + IntPtr p = NativeMethods.cairo_image_surface_create ( + format, width, height); + + return new Cairo.Surface (p, true); + } - public Cairo.Surface CreateSimilar ( - Cairo.Content content, int width, int height) - { - IntPtr p = NativeMethods.cairo_surface_create_similar ( - this.Handle, content, width, height); + public Cairo.Surface CreateSimilar ( + Cairo.Content content, int width, int height) + { + IntPtr p = NativeMethods.cairo_surface_create_similar ( + this.Handle, content, width, height); - return new Cairo.Surface (p, true); - } + return new Cairo.Surface (p, true); + } ~Surface () { @@ -136,9 +127,9 @@ namespace Cairo { } //[Obsolete ("Use Context.SetSource() followed by Context.Paint()")] - public void Show (Context gr, double x, double y) + public void Show (Context gr, double x, double y) { - NativeMethods.cairo_set_source_surface (gr.Handle, surface, x, y); + NativeMethods.cairo_set_source_surface (gr.Handle, handle, x, y); NativeMethods.cairo_paint (gr.Handle); } @@ -151,100 +142,91 @@ namespace Cairo { protected virtual void Dispose (bool disposing) { if (!disposing || CairoDebug.Enabled) - CairoDebug.OnDisposed (surface, disposing); - - if (!disposing|| surface == IntPtr.Zero) + CairoDebug.OnDisposed (handle, disposing); + + if (!disposing || handle == IntPtr.Zero) return; - lock (surfaces.SyncRoot) - surfaces.Remove (surface); - - NativeMethods.cairo_surface_destroy (surface); - surface = IntPtr.Zero; + NativeMethods.cairo_surface_destroy (handle); + handle = IntPtr.Zero; } - + public Status Finish () { - NativeMethods.cairo_surface_finish (surface); + NativeMethods.cairo_surface_finish (handle); return Status; } - + public void Flush () { - NativeMethods.cairo_surface_flush (surface); + NativeMethods.cairo_surface_flush (handle); } - + public void MarkDirty () { NativeMethods.cairo_surface_mark_dirty (Handle); } - + public void MarkDirty (Rectangle rectangle) { NativeMethods.cairo_surface_mark_dirty_rectangle (Handle, (int)rectangle.X, (int)rectangle.Y, (int)rectangle.Width, (int)rectangle.Height); } - - public IntPtr Handle { - get { - return surface; - } - } - public Device Device { - get { - IntPtr dev = NativeMethods.cairo_surface_get_device (surface); - return dev == IntPtr.Zero ? null : new Device (dev); + public IntPtr Handle { + get { + return handle; } } public PointD DeviceOffset { get { double x, y; - NativeMethods.cairo_surface_get_device_offset (surface, out x, out y); + NativeMethods.cairo_surface_get_device_offset (handle, out x, out y); return new PointD (x, y); } set { - NativeMethods.cairo_surface_set_device_offset (surface, value.X, value.Y); + NativeMethods.cairo_surface_set_device_offset (handle, value.X, value.Y); } } - + + [Obsolete ("Use Dispose()")] public void Destroy() { - Dispose (true); + Dispose (); } public void SetFallbackResolution (double x, double y) { - NativeMethods.cairo_surface_set_fallback_resolution (surface, x, y); + NativeMethods.cairo_surface_set_fallback_resolution (handle, x, y); } public void WriteToPng (string filename) { - NativeMethods.cairo_surface_write_to_png (surface, filename); + NativeMethods.cairo_surface_write_to_png (handle, filename); } - + [Obsolete ("Use Handle instead.")] - public IntPtr Pointer { - get { - return surface; + public IntPtr Pointer { + get { + return handle; } - } - + } + public Status Status { - get { return NativeMethods.cairo_surface_status (surface); } + get { return NativeMethods.cairo_surface_status (handle); } } public Content Content { - get { return NativeMethods.cairo_surface_get_content (surface); } + get { return NativeMethods.cairo_surface_get_content (handle); } } public SurfaceType SurfaceType { - get { return NativeMethods.cairo_surface_get_type (surface); } + get { return NativeMethods.cairo_surface_get_type (handle); } } public uint ReferenceCount { - get { return NativeMethods.cairo_surface_get_reference_count (surface); } + get { return NativeMethods.cairo_surface_get_reference_count (handle); } } - } + } } diff --git a/cairo/SurfacePattern.cs b/cairo/SurfacePattern.cs index 569c55cfc..5ba188fe1 100644 --- a/cairo/SurfacePattern.cs +++ b/cairo/SurfacePattern.cs @@ -1,4 +1,4 @@ -// +// // Mono.Cairo.Pattern.cs // // Author: Jordi Mas (jordi@ximian.com) @@ -14,10 +14,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 @@ -30,21 +30,21 @@ using System; namespace Cairo { - + public class SurfacePattern : Pattern { - internal SurfacePattern (IntPtr handle) : base (handle) + internal SurfacePattern (IntPtr handle, bool owned) : base (handle, owned) { } public SurfacePattern (Surface surface) + : base (NativeMethods.cairo_pattern_create_for_surface (surface.Handle), true) { - pattern = NativeMethods.cairo_pattern_create_for_surface (surface.Handle); } public Filter Filter { - set { NativeMethods.cairo_pattern_set_filter (pattern, value); } - get { return NativeMethods.cairo_pattern_get_filter (pattern); } + set { NativeMethods.cairo_pattern_set_filter (Handle, value); } + get { return NativeMethods.cairo_pattern_get_filter (Handle); } } } } diff --git a/cairo/SvgSurface.cs b/cairo/SvgSurface.cs index 10da981e0..418295011 100644 --- a/cairo/SvgSurface.cs +++ b/cairo/SvgSurface.cs @@ -37,16 +37,13 @@ namespace Cairo { } public SvgSurface (string filename, double width, double height) + : base (NativeMethods.cairo_svg_surface_create (filename, width, height), true) { - surface = NativeMethods.cairo_svg_surface_create (filename, width, height); - lock (surfaces.SyncRoot){ - surfaces [surface] = this; - } } public void RestrictToVersion (SvgVersion version) { - NativeMethods.cairo_svg_surface_restrict_to_version (surface, version); + NativeMethods.cairo_svg_surface_restrict_to_version (Handle, version); } } } diff --git a/cairo/Win32Surface.cs b/cairo/Win32Surface.cs index fbb22270a..dd244286d 100644 --- a/cairo/Win32Surface.cs +++ b/cairo/Win32Surface.cs @@ -37,12 +37,8 @@ namespace Cairo { } public Win32Surface (IntPtr hdc) + : base (NativeMethods.cairo_win32_surface_create (hdc), true) { - surface = NativeMethods.cairo_win32_surface_create (hdc); - lock (surfaces.SyncRoot) { - surfaces [surface] = this; - } } } - } diff --git a/cairo/XcbSurface.cs b/cairo/XcbSurface.cs index 97f5f2f6f..142ebf9e3 100644 --- a/cairo/XcbSurface.cs +++ b/cairo/XcbSurface.cs @@ -36,24 +36,19 @@ namespace Cairo { } public XcbSurface (IntPtr connection, uint drawable, IntPtr visual, int width, int height) + : base (NativeMethods.cairo_xcb_surface_create (connection, drawable, visual, width, height), true) { - surface = NativeMethods.cairo_xcb_surface_create (connection, drawable, visual, width, height); - lock (surfaces.SyncRoot) { - surfaces [surface] = this; - } } public static XcbSurface FromBitmap (IntPtr connection, uint bitmap, IntPtr screen, int width, int height) { - IntPtr ptr; - - ptr = NativeMethods.cairo_xcb_surface_create_for_bitmap (connection, bitmap, screen, width, height); + IntPtr ptr = NativeMethods.cairo_xcb_surface_create_for_bitmap (connection, bitmap, screen, width, height); return new XcbSurface (ptr, true); } public void SetSize (int width, int height) { - NativeMethods.cairo_xcb_surface_set_size (surface, width, height); + NativeMethods.cairo_xcb_surface_set_size (Handle, width, height); } } } diff --git a/cairo/XlibSurface.cs b/cairo/XlibSurface.cs index ef010feea..c0003a491 100644 --- a/cairo/XlibSurface.cs +++ b/cairo/XlibSurface.cs @@ -39,11 +39,8 @@ namespace Cairo { public class XlibSurface : Surface { public XlibSurface (IntPtr display, IntPtr drawable, IntPtr visual, int width, int height) + : base (NativeMethods.cairo_xlib_surface_create (display, drawable, visual, width, height), true) { - surface = NativeMethods.cairo_xlib_surface_create (display, drawable, visual, width, height); - lock (surfaces.SyncRoot){ - surfaces [surface] = this; - } } public XlibSurface (IntPtr ptr, bool own) : base (ptr, own) @@ -52,48 +49,46 @@ namespace Cairo { public static XlibSurface FromBitmap (IntPtr display, IntPtr bitmap, IntPtr screen, int width, int height) { - IntPtr ptr; - - ptr = NativeMethods.cairo_xlib_surface_create_for_bitmap (display, bitmap, screen, width, height); + IntPtr ptr = NativeMethods.cairo_xlib_surface_create_for_bitmap (display, bitmap, screen, width, height); return new XlibSurface(ptr, true); } public void SetDrawable (IntPtr drawable, int width, int height) { - NativeMethods.cairo_xlib_surface_set_drawable (surface, drawable, width, height); + NativeMethods.cairo_xlib_surface_set_drawable (Handle, drawable, width, height); } public void SetSize (int width, int height) { - NativeMethods.cairo_xlib_surface_set_size (surface, width, height); + NativeMethods.cairo_xlib_surface_set_size (Handle, width, height); } public int Depth { - get { return NativeMethods.cairo_xlib_surface_get_depth (surface); } + get { return NativeMethods.cairo_xlib_surface_get_depth (Handle); } } public IntPtr Display { - get { return NativeMethods.cairo_xlib_surface_get_display (surface); } + get { return NativeMethods.cairo_xlib_surface_get_display (Handle); } } public IntPtr Drawable { - get { return NativeMethods.cairo_xlib_surface_get_drawable (surface); } + get { return NativeMethods.cairo_xlib_surface_get_drawable (Handle); } } public int Height { - get { return NativeMethods.cairo_xlib_surface_get_height (surface); } + get { return NativeMethods.cairo_xlib_surface_get_height (Handle); } } public IntPtr Screen { - get { return NativeMethods.cairo_xlib_surface_get_screen (surface); } + get { return NativeMethods.cairo_xlib_surface_get_screen (Handle); } } public IntPtr Visual { - get { return NativeMethods.cairo_xlib_surface_get_visual (surface); } + get { return NativeMethods.cairo_xlib_surface_get_visual (Handle); } } public int Width { - get { return NativeMethods.cairo_xlib_surface_get_width (surface); } + get { return NativeMethods.cairo_xlib_surface_get_width (Handle); } } } diff --git a/cairo/cairo-api.xml b/cairo/cairo-api.xml index 8ae93c016..35415505b 100644 --- a/cairo/cairo-api.xml +++ b/cairo/cairo-api.xml @@ -7,5 +7,5 @@ - + diff --git a/gdk/Window.cs b/gdk/Window.cs index 75c2d8235..7f3f017f3 100644 --- a/gdk/Window.cs +++ b/gdk/Window.cs @@ -41,7 +41,7 @@ namespace Gdk { public Cairo.Pattern BackgroundPattern { get { IntPtr raw_ret = gdk_window_get_background_pattern(Handle); - Cairo.Pattern ret = Cairo.Pattern.Lookup (raw_ret); + Cairo.Pattern ret = Cairo.Pattern.Lookup (raw_ret, true); return ret; } set {