ryujinx-archive/GtkSharp
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

cairo: Introduce the concept of reference ownership

Browse source 
Also:
  * improving naming consistency
  * obsolete old/broken stuff
  * clean up tabs/space mix

NOTE: this removes the wrapper caches for Pattern and Surface as
there was no reliable way to clear them.

This is a merge from changes in Mono.Cairo in mono 3.2.
This commit is contained in:
Michael Hutchinson 2013-07-26 11:45:26 -05:00 committed by Bertrand Lorentz
parent 5a78a5d177
commit 38d1a3f13e
24 changed files with 773 additions and 828 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

823
cairo/Context.cs
View file

File diff suppressed because it is too large Load diff

5
cairo/DirectFBSurface.cs
View file

@ -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;
}
}
}
}

19
cairo/FontFace.cs
View file

@ -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);
}

5
cairo/FontOptions.cs
View file

@ -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 ()

5
cairo/GlitzSurface.cs
View file

@ -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;
}
}
}
}

21
cairo/Gradient.cs
View file

@ -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;
}
}

57
cairo/ImageSurface.cs
View file

@ -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); }
}
}
}

21
cairo/LinearGradient.cs
View file

@ -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;
}
}
}
}
}
}

136
cairo/Matrix.cs
View file

@ -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 ();
}
}
}
}

13
cairo/PSSurface.cs
View file

@ -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);
}
}
}

19
cairo/Path.cs
View file

@ -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<Path> (handle, disposing);
if (!disposing|| handle == IntPtr.Zero)
if (!disposing || handle == IntPtr.Zero)
return;
NativeMethods.cairo_path_destroy (handle);

121
cairo/Pattern.cs
View file

@ -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); }
}
}
}
}

7
cairo/PdfSurface.cs
View file

@ -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);
}
}
}

12
cairo/RadialGradient.cs
View file

@ -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);
}
}
}

39
cairo/ScaledFont.cs
View file

@ -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);
}
}
}

33
cairo/SolidPattern.cs
View file

@ -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);
}
}
}
}
}
}

194
cairo/Surface.cs
View file

@ -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> (surface, disposing);
if (!disposing|| surface == IntPtr.Zero)
CairoDebug.OnDisposed<Surface> (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); }
}
}
}
}

16
cairo/SurfacePattern.cs
View file

@ -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); }
}
}
}

7
cairo/SvgSurface.cs
View file

@ -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);
}
}
}

6
cairo/Win32Surface.cs
View file

@ -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;
}
}
}
}

11
cairo/XcbSurface.cs
View file

@ -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);
}
}
}

27
cairo/XlibSurface.cs
View file

@ -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); }
}
}

2
cairo/cairo-api.xml
View file

@ -7,5 +7,5 @@
<symbol type="manual" cname="cairo_font_options_t" name="Cairo.FontOptions"/>
<symbol type="manual" cname="cairo_region_t" name="Cairo.Region"/>
<symbol type="marshal" cname="cairo_pattern_t" name="Cairo.Pattern" marshal_type="IntPtr" call_fmt="{0}.Handle" from_fmt="Cairo.Pattern.Lookup ({0})" />
<symbol type="marshal" cname="cairo_surface_t" name="Cairo.Surface" marshal_type="IntPtr" call_fmt="{0}.Handle" from_fmt="Cairo.Surface.LookupSurface ({0})" />
<symbol type="marshal" cname="cairo_surface_t" name="Cairo.Surface" marshal_type="IntPtr" call_fmt="{0}.Handle" from_fmt="Cairo.Surface.Lookup ({0}, true)" />
</api>

2
gdk/Window.cs
View file

@ -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 {