cairo 0.0.4

Cairo bindings
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use std::mem;

#[repr(C)]
pub struct Matrix {
  xx: f64,
  yx: f64,
  xy: f64,
  yy: f64,
  x0: f64,
  y0: f64
}

impl Matrix {
  pub fn new(xx: f64, yx: f64, xy: f64, yy: f64, x0: f64, y0: f64) -> Matrix {
    unsafe {
      let mut this:Matrix = mem::zeroed();
      cairo_matrix_init(&mut this, xx, yx, xy, yy, x0, y0);
      return this;
    }
  }

  pub fn identity() -> Matrix {
    unsafe {
      let mut this:Matrix = mem::zeroed();
      cairo_matrix_init_identity(&mut this);
      return this;
    }
  }

  pub fn for_translation(x0: f64, y0: f64) -> Matrix {
    unsafe {
      let mut this:Matrix = mem::zeroed();
      cairo_matrix_init_translate(&mut this, x0, y0);
      return this;
    }
  }

  pub fn for_scale(sx: f64, sy: f64) -> Matrix {
    unsafe {
      let mut this:Matrix = mem::zeroed();
      cairo_matrix_init_scale(&mut this, sx, sy);
      return this;
    }
  }

  pub fn for_rotation(radians: f64) -> Matrix {
    unsafe {
      let mut this:Matrix = mem::zeroed();
      cairo_matrix_init_rotate(&mut this, radians);
      return this;
    }
  }

  pub fn multiply(a: &mut Matrix, b: &mut Matrix) -> Matrix {
    unsafe {
      let mut this:Matrix = mem::zeroed();
      cairo_matrix_multiply(&mut this, a, b);
      return this;
    }
  }

  pub fn translate(&mut self, x0: f64, y0: f64) {
    unsafe {
      cairo_matrix_translate(self, x0, y0);
    }
  }

  pub fn scale(&mut self, sx: f64, sy: f64) {
    unsafe {
      cairo_matrix_scale(self, sx, sy);
    }
  }

  pub fn rotate(&mut self, radians: f64) {
    unsafe {
      cairo_matrix_rotate(self, radians);
    }
  }

  pub fn transform_distance(&mut self) -> (f64, f64) {
    unsafe {
      let mut dx:f64 = mem::zeroed();
      let mut dy:f64 = mem::zeroed();
      cairo_matrix_transform_distance(self, &mut dx, &mut dy);
      return (dx, dy);
    }
  }

  pub fn transform_point(&mut self) -> (f64, f64) {
    unsafe {
      let mut x:f64 = mem::zeroed();
      let mut y:f64 = mem::zeroed();
      cairo_matrix_transform_point(self, &mut x, &mut y);
      return (x, y);
    }
  }

  pub fn invert(&mut self) -> super::Status {
    unsafe {
      let foreign_result = cairo_matrix_invert(self);
      return foreign_result;
    }
  }
}

extern {
  fn cairo_matrix_init(this: *mut Matrix, xx: f64, yx: f64, xy: f64, yy: f64, x0: f64, y0: f64);
  fn cairo_matrix_init_identity(this: *mut Matrix);
  fn cairo_matrix_init_translate(this: *mut Matrix, x0: f64, y0: f64);
  fn cairo_matrix_init_scale(this: *mut Matrix, sx: f64, sy: f64);
  fn cairo_matrix_init_rotate(this: *mut Matrix, radians: f64);
  fn cairo_matrix_multiply(this: *mut Matrix, a: *mut Matrix, b: *mut Matrix);
  fn cairo_matrix_translate(self_arg: *mut Matrix, x0: f64, y0: f64);
  fn cairo_matrix_scale(self_arg: *mut Matrix, sx: f64, sy: f64);
  fn cairo_matrix_rotate(self_arg: *mut Matrix, radians: f64);
  fn cairo_matrix_transform_distance(self_arg: *mut Matrix, dx: *mut f64, dy: *mut f64);
  fn cairo_matrix_transform_point(self_arg: *mut Matrix, x: *mut f64, y: *mut f64);
  fn cairo_matrix_invert(self_arg: *mut Matrix) -> super::Status;
}