1 /*
2  * This file is part of gtkD.
3  *
4  * gtkD is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU Lesser General Public License
6  * as published by the Free Software Foundation; either version 3
7  * of the License, or (at your option) any later version, with
8  * some exceptions, please read the COPYING file.
9  *
10  * gtkD is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public License
16  * along with gtkD; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
18  */
19  
20 // generated automatically - do not change
21 // find conversion definition on APILookup.txt
22 // implement new conversion functionalities on the wrap.utils pakage
23 
24 /*
25  * Conversion parameters:
26  * inFile  = cairo-cairo-matrix-t.html
27  * outPack = cairo
28  * outFile = Matrix
29  * strct   = cairo_matrix_t
30  * realStrct=
31  * ctorStrct=
32  * clss    = Matrix
33  * interf  = 
34  * class Code: No
35  * interface Code: No
36  * template for:
37  * extend  = 
38  * implements:
39  * prefixes:
40  * 	- cairo_matrix_
41  * omit structs:
42  * omit prefixes:
43  * omit code:
44  * omit signals:
45  * imports:
46  * 	- glib.Str
47  * structWrap:
48  * 	- cairo_matrix_t* -> Matrix
49  * module aliases:
50  * local aliases:
51  * overrides:
52  */
53 
54 module cairo.Matrix;
55 
56 public  import gtkc.cairotypes;
57 
58 private import gtkc.cairo;
59 private import glib.ConstructionException;
60 
61 private import glib.Str;
62 
63 
64 
65 /**
66  * cairo_matrix_t is used throughout cairo to convert between different
67  * coordinate spaces. A cairo_matrix_t holds an affine transformation,
68  * such as a scale, rotation, shear, or a combination of these.
69  * The transformation of a point (x,y)
70  * is given by:
71  *
72  * x_new = xx * x + xy * y + x0;
73  * y_new = yx * x + yy * y + y0;
74  *
75  * The current transformation matrix of a cairo_t, represented as a
76  * cairo_matrix_t, defines the transformation from user-space
77  * coordinates to device-space coordinates. See cairo_get_matrix() and
78  * cairo_set_matrix().
79  */
80 public class Matrix
81 {
82 	
83 	/** the main Gtk struct */
84 	protected cairo_matrix_t* cairo_matrix;
85 	
86 	
87 	/** Get the main Gtk struct */
88 	public cairo_matrix_t* getMatrixStruct()
89 	{
90 		return cairo_matrix;
91 	}
92 	
93 	
94 	/** the main Gtk struct as a void* */
95 	protected void* getStruct()
96 	{
97 		return cast(void*)cairo_matrix;
98 	}
99 	
100 	/**
101 	 * Sets our main struct and passes it to the parent class
102 	 */
103 	public this (cairo_matrix_t* cairo_matrix, bool ownedRef = false)
104 	{
105 		this.cairo_matrix = cairo_matrix;
106 	}
107 	
108 	/**
109 	 */
110 	
111 	/**
112 	 * Sets matrix to be the affine transformation given by
113 	 * xx, yx, xy, yy, x0, y0. The transformation is given
114 	 * Since 1.0
115 	 * Params:
116 	 * xx = xx component of the affine transformation
117 	 * yx = yx component of the affine transformation
118 	 * xy = xy component of the affine transformation
119 	 * yy = yy component of the affine transformation
120 	 * x0 = X translation component of the affine transformation
121 	 * y0 = Y translation component of the affine transformation
122 	 */
123 	public void init(double xx, double yx, double xy, double yy, double x0, double y0)
124 	{
125 		// void cairo_matrix_init (cairo_matrix_t *matrix,  double xx,  double yx,  double xy,  double yy,  double x0,  double y0);
126 		cairo_matrix_init(cairo_matrix, xx, yx, xy, yy, x0, y0);
127 	}
128 	
129 	/**
130 	 * Modifies matrix to be an identity transformation.
131 	 * Since 1.0
132 	 */
133 	public void initIdentity()
134 	{
135 		// void cairo_matrix_init_identity (cairo_matrix_t *matrix);
136 		cairo_matrix_init_identity(cairo_matrix);
137 	}
138 	
139 	/**
140 	 * Initializes matrix to a transformation that translates by tx and
141 	 * ty in the X and Y dimensions, respectively.
142 	 * Since 1.0
143 	 * Params:
144 	 * tx = amount to translate in the X direction
145 	 * ty = amount to translate in the Y direction
146 	 */
147 	public void initTranslate(double tx, double ty)
148 	{
149 		// void cairo_matrix_init_translate (cairo_matrix_t *matrix,  double tx,  double ty);
150 		cairo_matrix_init_translate(cairo_matrix, tx, ty);
151 	}
152 	
153 	/**
154 	 * Initializes matrix to a transformation that scales by sx and sy
155 	 * in the X and Y dimensions, respectively.
156 	 * Since 1.0
157 	 * Params:
158 	 * sx = scale factor in the X direction
159 	 * sy = scale factor in the Y direction
160 	 */
161 	public void initScale(double sx, double sy)
162 	{
163 		// void cairo_matrix_init_scale (cairo_matrix_t *matrix,  double sx,  double sy);
164 		cairo_matrix_init_scale(cairo_matrix, sx, sy);
165 	}
166 	
167 	/**
168 	 * Initialized matrix to a transformation that rotates by radians.
169 	 * Since 1.0
170 	 * Params:
171 	 * radians = angle of rotation, in radians. The direction of rotation
172 	 * is defined such that positive angles rotate in the direction from
173 	 * the positive X axis toward the positive Y axis. With the default
174 	 * axis orientation of cairo, positive angles rotate in a clockwise
175 	 * direction.
176 	 */
177 	public void initRotate(double radians)
178 	{
179 		// void cairo_matrix_init_rotate (cairo_matrix_t *matrix,  double radians);
180 		cairo_matrix_init_rotate(cairo_matrix, radians);
181 	}
182 	
183 	/**
184 	 * Applies a translation by tx, ty to the transformation in
185 	 * matrix. The effect of the new transformation is to first translate
186 	 * the coordinates by tx and ty, then apply the original transformation
187 	 * to the coordinates.
188 	 * Since 1.0
189 	 * Params:
190 	 * tx = amount to translate in the X direction
191 	 * ty = amount to translate in the Y direction
192 	 */
193 	public void translate(double tx, double ty)
194 	{
195 		// void cairo_matrix_translate (cairo_matrix_t *matrix,  double tx,  double ty);
196 		cairo_matrix_translate(cairo_matrix, tx, ty);
197 	}
198 	
199 	/**
200 	 * Applies scaling by sx, sy to the transformation in matrix. The
201 	 * effect of the new transformation is to first scale the coordinates
202 	 * by sx and sy, then apply the original transformation to the coordinates.
203 	 * Since 1.0
204 	 * Params:
205 	 * sx = scale factor in the X direction
206 	 * sy = scale factor in the Y direction
207 	 */
208 	public void scale(double sx, double sy)
209 	{
210 		// void cairo_matrix_scale (cairo_matrix_t *matrix,  double sx,  double sy);
211 		cairo_matrix_scale(cairo_matrix, sx, sy);
212 	}
213 	
214 	/**
215 	 * Applies rotation by radians to the transformation in
216 	 * matrix. The effect of the new transformation is to first rotate the
217 	 * coordinates by radians, then apply the original transformation
218 	 * to the coordinates.
219 	 * Since 1.0
220 	 * Params:
221 	 * radians = angle of rotation, in radians. The direction of rotation
222 	 * is defined such that positive angles rotate in the direction from
223 	 * the positive X axis toward the positive Y axis. With the default
224 	 * axis orientation of cairo, positive angles rotate in a clockwise
225 	 * direction.
226 	 */
227 	public void rotate(double radians)
228 	{
229 		// void cairo_matrix_rotate (cairo_matrix_t *matrix,  double radians);
230 		cairo_matrix_rotate(cairo_matrix, radians);
231 	}
232 	
233 	/**
234 	 * Changes matrix to be the inverse of its original value. Not
235 	 * all transformation matrices have inverses; if the matrix
236 	 * collapses points together (it is degenerate),
237 	 * then it has no inverse and this function will fail.
238 	 * Since 1.0
239 	 * Returns: If matrix has an inverse, modifies matrix to be the inverse matrix and returns CAIRO_STATUS_SUCCESS. Otherwise, returns CAIRO_STATUS_INVALID_MATRIX.
240 	 */
241 	public cairo_status_t invert()
242 	{
243 		// cairo_status_t cairo_matrix_invert (cairo_matrix_t *matrix);
244 		return cairo_matrix_invert(cairo_matrix);
245 	}
246 	
247 	/**
248 	 * Multiplies the affine transformations in a and b together
249 	 * and stores the result in result. The effect of the resulting
250 	 * transformation is to first apply the transformation in a to the
251 	 * coordinates and then apply the transformation in b to the
252 	 * coordinates.
253 	 * It is allowable for result to be identical to either a or b.
254 	 * Since 1.0
255 	 * Params:
256 	 * a = a cairo_matrix_t
257 	 * b = a cairo_matrix_t
258 	 */
259 	public void multiply(Matrix a, Matrix b)
260 	{
261 		// void cairo_matrix_multiply (cairo_matrix_t *result,  const cairo_matrix_t *a,  const cairo_matrix_t *b);
262 		cairo_matrix_multiply(cairo_matrix, (a is null) ? null : a.getMatrixStruct(), (b is null) ? null : b.getMatrixStruct());
263 	}
264 	
265 	/**
266 	 * Transforms the distance vector (dx,dy) by matrix. This is
267 	 * similar to cairo_matrix_transform_point() except that the translation
268 	 * components of the transformation are ignored. The calculation of
269 	 * Since 1.0
270 	 * Params:
271 	 * dx = X component of a distance vector. An in/out parameter
272 	 * dy = Y component of a distance vector. An in/out parameter
273 	 */
274 	public void transformDistance(ref double dx, ref double dy)
275 	{
276 		// void cairo_matrix_transform_distance (const cairo_matrix_t *matrix,  double *dx,  double *dy);
277 		cairo_matrix_transform_distance(cairo_matrix, &dx, &dy);
278 	}
279 	
280 	/**
281 	 * Transforms the point (x, y) by matrix.
282 	 * Since 1.0
283 	 * Params:
284 	 * x = X position. An in/out parameter
285 	 * y = Y position. An in/out parameter
286 	 */
287 	public void transformPoint(ref double x, ref double y)
288 	{
289 		// void cairo_matrix_transform_point (const cairo_matrix_t *matrix,  double *x,  double *y);
290 		cairo_matrix_transform_point(cairo_matrix, &x, &y);
291 	}
292 }