// 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
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 ()
{
//
// is 32 bits
//
int ptr_size = Marshal.SizeOf (typeof (IntPtr));
-
+
PlatformID platform = Environment.OSVersion.Platform;
if (platform == PlatformID.Win32NT ||
platform == PlatformID.Win32S ||
native_glyph_size = Marshal.SizeOf (typeof (Glyph));
}
}
-
- public Context (Surface surface)
- {
- state = NativeMethods.cairo_create (surface.Handle);
- }
-
- public Context (IntPtr state)
+
+ public Context (Surface surface) : this (NativeMethods.cairo_create (surface.Handle), true)
{
- this.state = state;
+ }
+
+
+ public Context (IntPtr handle, bool owner)
+ {
+ this.handle = handle;
+ if (!owner)
+ NativeMethods.cairo_reference (handle);
if (CairoDebug.Enabled)
- CairoDebug.OnAllocated (state);
+ 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)
- {
+
+ protected virtual void Dispose (bool disposing)
+ {
if (!disposing || CairoDebug.Enabled)
- CairoDebug.OnDisposed<Context> (state, disposing);
+ CairoDebug.OnDisposed<Context> (handle, disposing);
- if (!disposing|| state == IntPtr.Zero)
+ 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 Restore ()
- {
- NativeMethods.cairo_restore (state);
- }
+ public void Save ()
+ {
+ NativeMethods.cairo_save (handle);
+ }
+
+ public void Restore ()
+ {
+ NativeMethods.cairo_restore (handle);
+ }
public Antialias Antialias {
- get { return NativeMethods.cairo_get_antialias (state); }
- set { NativeMethods.cairo_set_antialias (state, 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);
- }
- }
-
- [Obsolete ("Use Color property")]
- public Cairo.Color ColorRgb {
- set {
+ get { return NativeMethods.cairo_get_antialias (handle); }
+ set { NativeMethods.cairo_set_antialias (handle, value); }
+ }
+
+ public Cairo.Status Status {
+ get {
+ return NativeMethods.cairo_status (handle);
+ }
+ }
+
+ 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 {
+ 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.Pointer);
- }
-
+ return NativeMethods.cairo_get_tolerance (handle);
+ }
+
+ set {
+ NativeMethods.cairo_set_tolerance (handle, value);
+ }
+ }
+
+ public Cairo.FillRule FillRule {
+ set {
+ NativeMethods.cairo_set_fill_rule (handle, value);
+ }
+
get {
- return new Pattern (NativeMethods.cairo_get_source (state));
+ return NativeMethods.cairo_get_fill_rule (handle);
}
- }
-
- public Pattern Source {
- set {
- NativeMethods.cairo_set_source (state, value.Pointer);
- }
-
+ }
+
+ 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 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 Cairo.Surface Target {
- set {
- if (state != IntPtr.Zero)
- NativeMethods.cairo_destroy (state);
-
- state = NativeMethods.cairo_create (value.Handle);
- }
-
- get {
- return Cairo.Surface.LookupExternalSurface (
- NativeMethods.cairo_get_target (state));
- }
- }
-
- public Cairo.ScaledFont ScaledFont {
- set {
- NativeMethods.cairo_set_scaled_font (state, value.Handle);
- }
-
- get {
- return new ScaledFont (NativeMethods.cairo_get_scaled_font (state));
- }
- }
+ 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 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 ScaledFont ScaledFont {
+ set {
+ NativeMethods.cairo_set_scaled_font (handle, value.Handle);
+ }
+
+ 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);
- }
+ {
+ NativeMethods.cairo_line_to (handle, x, y);
+ }
- public void CurveTo (PointD p1, PointD p2, PointD p3)
+ 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)
- {
+
+ public void RelMoveTo (double dx, double dy)
+ {
+ NativeMethods.cairo_rel_move_to (handle, dx, dy);
+ }
+
+ public void RelLineTo (Distance d)
+ {
RelLineTo (d.Dx, d.Dy);
- }
-
- public void RelLineTo (double dx, double dy)
+ }
+
+ public void RelLineTo (double dx, double dy)
{
- NativeMethods.cairo_rel_line_to (state, dx, dy);
+ NativeMethods.cairo_rel_line_to (handle, dx, dy);
}
-
- public void RelCurveTo (Distance d1, Distance d2, Distance d3)
+
+ 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 void Rectangle (double x, double y, double width, double height)
+ {
+ NativeMethods.cairo_rectangle (handle, x, y, width, height);
+ }
- public Path CopyPath ()
+ public void ClosePath ()
{
- return new Path (NativeMethods.cairo_copy_path (state));
+ 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);
}
-
+
#endregion
#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.Pointer);
+ 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 (handle);
+ }
+
+ public void StrokePreserve ()
+ {
+ NativeMethods.cairo_stroke_preserve (handle);
}
-
- public void Stroke ()
- {
- NativeMethods.cairo_stroke (state);
- }
-
- public void StrokePreserve ()
- {
- NativeMethods.cairo_stroke_preserve (state);
- }
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, y2);
}
- 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, y2);
}
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 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 (handle, sx, sy);
+ }
- public void Scale (double sx, double sy)
- {
- NativeMethods.cairo_scale (state, 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);
+ NativeMethods.cairo_transform (handle, m);
}
-
-#region Methods that will become obsolete in the long term, after 1.2.5 becomes wildly available
-
- //[Obsolete("Use UserToDevice instead")]
+
+ [Obsolete("Use UserToDevice instead")]
public void TransformPoint (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);
}
-
- //[Obsolete("Use UserToDeviceDistance instead")]
- public void TransformDistance (ref double dx, ref double dy)
+
+ [Obsolete("Use UserToDeviceDistance instead")]
+ public void TransformDistance (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);
}
-
- //[Obsolete("Use InverseTransformPoint instead")]
+
+ [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_device_to_user (handle, ref x, ref y);
}
- //[Obsolete("Use DeviceToUserDistance instead")]
+ [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 {
+ public Matrix Matrix {
+ set {
+ NativeMethods.cairo_set_matrix (handle, value);
+ }
+
+ get {
Matrix m = new Matrix();
- NativeMethods.cairo_get_matrix (state, m);
- return m;
- }
- }
+ 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)
{
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)]
} 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;
}
return dest;
}
- public void ShowGlyphs (Glyph[] glyphs)
+ public void ShowGlyphs (Glyph[] glyphs)
{
- IntPtr ptr;
+ IntPtr ptr;
+
+ ptr = FromGlyphToUnManagedMemory (glyphs);
- ptr = FromGlyphToUnManagedMemory (glyphs);
-
- NativeMethods.cairo_show_glyphs (state, ptr, glyphs.Length);
+ NativeMethods.cairo_show_glyphs (handle, ptr, glyphs.Length);
- Marshal.FreeHGlobal (ptr);
+ 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.")]
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);
}
private static byte[] TerminateUtf8(byte[] utf8)
public void ShowText(string str)
{
- NativeMethods.cairo_show_text(state, TerminateUtf8(str));
+ NativeMethods.cairo_show_text (handle, TerminateUtf8(str));
}
public void ShowText(byte[] utf8)
{
- NativeMethods.cairo_show_text(state, TerminateUtf8(utf8));
+ NativeMethods.cairo_show_text (handle, TerminateUtf8(utf8));
}
public void TextPath(string str)
{
- NativeMethods.cairo_text_path(state, TerminateUtf8(str));
+ NativeMethods.cairo_text_path (handle, TerminateUtf8(str));
}
public void TextPath(byte[] utf8)
{
- NativeMethods.cairo_text_path(state, TerminateUtf8(utf8));
+ NativeMethods.cairo_text_path (handle, TerminateUtf8(utf8));
}
public TextExtents TextExtents(string s)
{
TextExtents extents;
- NativeMethods.cairo_text_extents(state, TerminateUtf8(s), out extents);
+ NativeMethods.cairo_text_extents (handle, TerminateUtf8(s), out extents);
return extents;
}
public TextExtents TextExtents(byte[] utf8)
{
TextExtents extents;
- NativeMethods.cairo_text_extents(state, TerminateUtf8(utf8), out extents);
+ NativeMethods.cairo_text_extents (handle, TerminateUtf8(utf8), out extents);
return extents;
}
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);
return extents;
}
- }
+ }
}
}
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;
- }
}
}
}
{
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 ()
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);
}
{
IntPtr handle;
- public FontOptions ()
+ public FontOptions () : this (NativeMethods.cairo_font_options_create ())
{
- handle = NativeMethods.cairo_font_options_create ();
}
~FontOptions ()
[Obsolete ("Use Dispose()")]
public void Destroy ()
{
- Dispose ();
+ NativeMethods.cairo_font_options_destroy (handle);
}
public void Dispose ()
}
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;
- }
}
}
}
-//
+//
// Mono.Cairo.Gradient.cs
//
// Author: Jordi Mas (jordi@ximian.com)
// 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
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 ()
{
}
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;
}
}
// 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
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);
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); }
}
}
}
-//
+//
// Mono.Cairo.LinearGradient.cs
//
// Author: Jordi Mas (jordi@ximian.com)
// 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
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;
- }
- }
-
+ }
+ }
}
}
// 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
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)
+
+
+ public void TransformDistance (ref double dx, ref double dy)
{
- NativeMethods.cairo_matrix_transform_distance (this, ref dx, ref 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 TransformPoint (ref double x, ref double y)
+ {
+ NativeMethods.cairo_matrix_transform_point (this, ref x, ref y);
}
public override String ToString ()
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 &&
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))
else
return (this == (Matrix) o);
}
-
+
public override int GetHashCode()
{
return (int)this.Xx ^ (int)this.Xx>>32 ^
(int)this.X0 ^ (int)this.X0>>32 ^
(int)this.Y0 ^ (int)this.Y0>>32;
}
-
+
public object Clone()
{
return this.MemberwiseClone ();
}
-
- }
+
+ }
}
}
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_begin_page_setup (surface);
+ NativeMethods.cairo_ps_surface_begin_page_setup (Handle);
}
public void BeginSetup ()
{
- NativeMethods.cairo_ps_surface_begin_setup (surface);
+ NativeMethods.cairo_ps_surface_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);
}
}
}
// 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
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;
Dispose (false);
}
-
+ public IntPtr Handle { get { return handle; } }
+
public void Dispose ()
{
Dispose (true);
GC.SuppressFinalize (this);
}
-
- protected virtual void Dispose (bool disposing)
- {
+
+ protected virtual void Dispose (bool disposing)
+ {
if (!disposing || CairoDebug.Enabled)
CairoDebug.OnDisposed<Path> (handle, disposing);
-
+
if (!disposing|| handle == IntPtr.Zero)
return;
- NativeMethods.cairo_path_destroy (handle);
+ NativeMethods.cairo_path_destroy (handle);
handle = IntPtr.Zero;
- }
- }
+ }
+ }
}
-//
+//
// Mono.Cairo.Pattern.cs
//
// Author: Jordi Mas (jordi@ximian.com)
namespace Cairo {
- public class Pattern : IDisposable
- {
+ public class Pattern : IDisposable
+ {
+ [Obsolete]
protected IntPtr pattern = IntPtr.Zero;
- internal 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 ();
+ [Obsolete]
+ protected Pattern ()
+ {
+ }
- internal Pattern (IntPtr handle)
+ internal Pattern (IntPtr handle, bool owned)
{
- lock (patterns){
- patterns [ptr] = this;
- }
-
Handle = handle;
+ if (!owned)
+ NativeMethods.cairo_pattern_reference (handle);
if (CairoDebug.Enabled)
CairoDebug.OnAllocated (handle);
}
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 ()
{
NativeMethods.cairo_pattern_destroy (Handle);
Handle = IntPtr.Zero;
- lock (patterns){
- patterns.Remove (this);
- }
}
[Obsolete ("Use Dispose()")]
- public void Destroy ()
- {
+ public void Destroy ()
+ {
NativeMethods.cairo_pattern_destroy (pattern);
- }
-
+ }
+
public Status Status
{
- get { return NativeMethods.cairo_pattern_status (pattern); }
+ get { return NativeMethods.cairo_pattern_status (Handle); }
}
public Extend Extend
{
- get { return NativeMethods.cairo_pattern_get_extend (pattern); }
- set { NativeMethods.cairo_pattern_set_extend (pattern, value); }
+ 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 (pattern, 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;
- }
- }
+ }
+ }
+#pragma warning disable 612
public IntPtr Handle {
get { return pattern; }
private set { pattern = value; }
}
- public IntPtr Pointer {
- get { return pattern; }
- }
+#pragma warning restore 612
+
+ [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); }
}
- }
+ }
}
}
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);
}
}
}
-//
+//
// Mono.Cairo.Pattern.cs
//
// Author: Jordi Mas (jordi@ximian.com)
// 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
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);
}
}
}
{
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)
{
}
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 {
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);
+ }
}
}
-//
+//
// Mono.Cairo.Pattern.cs
//
// Author: Jordi Mas (jordi@ximian.com)
// 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
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);
- }
- }
+ }
+ }
}
}
// 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
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;
- }
- }
+ }
- static internal 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);
- }
+ 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 (
+ Cairo.Format format, int width, int height)
+ {
+ IntPtr p = NativeMethods.cairo_image_surface_create (
+ format, width, height);
- return new Cairo.Surface (p, true);
- }
+ 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 ()
{
}
//[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);
}
protected virtual void Dispose (bool disposing)
{
if (!disposing || CairoDebug.Enabled)
- CairoDebug.OnDisposed<Surface> (surface, disposing);
-
- if (!disposing|| surface == IntPtr.Zero)
- return;
+ CairoDebug.OnDisposed<Surface> (handle, disposing);
- lock (surfaces.SyncRoot)
- surfaces.Remove (surface);
+ if (!disposing|| handle == IntPtr.Zero)
+ return;
- 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 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);
}
}
-
+
public void Destroy()
{
Dispose (true);
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); }
}
- }
+ }
}
-//
+//
// Mono.Cairo.Pattern.cs
//
// Author: Jordi Mas (jordi@ximian.com)
// 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
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 Extend Extend {
- set { NativeMethods.cairo_pattern_set_extend (pattern, value); }
- get { return NativeMethods.cairo_pattern_get_extend (pattern); }
+ //no idea why this is here, the base one is identical, but we can't remove it now
+ public new Extend Extend {
+ set { NativeMethods.cairo_pattern_set_extend (Handle, value); }
+ get { return NativeMethods.cairo_pattern_get_extend (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); }
}
}
}
}
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);
}
}
}
}
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;
- }
}
}
-
}
}
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);
}
}
}
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)
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); }
}
}