1 

     2 /* =========================== Module _CG =========================== */

     3 

     4 #include "Python.h"

     5 

     6 

     7 

     8 #include "pymactoolbox.h"

     9 

    10 /* Macro to test whether a weak-loaded CFM function exists */

    11 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\

    12         PyErr_SetString(PyExc_NotImplementedError, \

    13         "Not available in this shared library/OS version"); \

    14         return NULL; \

    15     }} while(0)

    16 

    17 

    18 #include <ApplicationServices/ApplicationServices.h>

    19 

    20 extern int GrafObj_Convert(PyObject *, GrafPtr *);

    21 

    22 /*

    23 ** Manual converters

    24 */

    25 

    26 PyObject *CGPoint_New(CGPoint *itself)

    27 {

    28 

    29         return Py_BuildValue("(ff)",

    30                         itself->x,

    31                         itself->y);

    32 }

    33 

    34 int

    35 CGPoint_Convert(PyObject *v, CGPoint *p_itself)

    36 {

    37         if( !PyArg_Parse(v, "(ff)",

    38                         &p_itself->x,

    39                         &p_itself->y) )

    40                 return 0;

    41         return 1;

    42 }

    43 

    44 PyObject *CGRect_New(CGRect *itself)

    45 {

    46 

    47         return Py_BuildValue("(ffff)",

    48                         itself->origin.x,

    49                         itself->origin.y,

    50                         itself->size.width,

    51                         itself->size.height);

    52 }

    53 

    54 int

    55 CGRect_Convert(PyObject *v, CGRect *p_itself)

    56 {

    57         if( !PyArg_Parse(v, "(ffff)",

    58                         &p_itself->origin.x,

    59                         &p_itself->origin.y,

    60                         &p_itself->size.width,

    61                         &p_itself->size.height) )

    62                 return 0;

    63         return 1;

    64 }

    65 

    66 PyObject *CGAffineTransform_New(CGAffineTransform *itself)

    67 {

    68 

    69         return Py_BuildValue("(ffffff)",

    70                         itself->a,

    71                         itself->b,

    72                         itself->c,

    73                         itself->d,

    74                         itself->tx,

    75                         itself->ty);

    76 }

    77 

    78 int

    79 CGAffineTransform_Convert(PyObject *v, CGAffineTransform *p_itself)

    80 {

    81         if( !PyArg_Parse(v, "(ffffff)",

    82                         &p_itself->a,

    83                         &p_itself->b,

    84                         &p_itself->c,

    85                         &p_itself->d,

    86                         &p_itself->tx,

    87                         &p_itself->ty) )

    88                 return 0;

    89         return 1;

    90 }

    91 

    92 static PyObject *CG_Error;

    93 

    94 /* -------------------- Object type CGContextRef -------------------- */

    95 

    96 PyTypeObject CGContextRef_Type;

    97 

    98 #define CGContextRefObj_Check(x) ((x)->ob_type == &CGContextRef_Type || PyObject_TypeCheck((x), &CGContextRef_Type))

    99 

   100 typedef struct CGContextRefObject {

   101 	PyObject_HEAD

   102 	CGContextRef ob_itself;

   103 } CGContextRefObject;

   104 

   105 PyObject *CGContextRefObj_New(CGContextRef itself)

   106 {

   107 	CGContextRefObject *it;

   108 	it = PyObject_NEW(CGContextRefObject, &CGContextRef_Type);

   109 	if (it == NULL) return NULL;

   110 	it->ob_itself = itself;

   111 	return (PyObject *)it;

   112 }

   113 

   114 int CGContextRefObj_Convert(PyObject *v, CGContextRef *p_itself)

   115 {

   116 	if (!CGContextRefObj_Check(v))

   117 	{

   118 		PyErr_SetString(PyExc_TypeError, "CGContextRef required");

   119 		return 0;

   120 	}

   121 	*p_itself = ((CGContextRefObject *)v)->ob_itself;

   122 	return 1;

   123 }

   124 

   125 static void CGContextRefObj_dealloc(CGContextRefObject *self)

   126 {

   127 	CGContextRelease(self->ob_itself);

   128 	self->ob_type->tp_free((PyObject *)self);

   129 }

   130 

   131 static PyObject *CGContextRefObj_CGContextSaveGState(CGContextRefObject *_self, PyObject *_args)

   132 {

   133 	PyObject *_res = NULL;

   134 	if (!PyArg_ParseTuple(_args, ""))

   135 		return NULL;

   136 	CGContextSaveGState(_self->ob_itself);

   137 	Py_INCREF(Py_None);

   138 	_res = Py_None;

   139 	return _res;

   140 }

   141 

   142 static PyObject *CGContextRefObj_CGContextRestoreGState(CGContextRefObject *_self, PyObject *_args)

   143 {

   144 	PyObject *_res = NULL;

   145 	if (!PyArg_ParseTuple(_args, ""))

   146 		return NULL;

   147 	CGContextRestoreGState(_self->ob_itself);

   148 	Py_INCREF(Py_None);

   149 	_res = Py_None;

   150 	return _res;

   151 }

   152 

   153 static PyObject *CGContextRefObj_CGContextScaleCTM(CGContextRefObject *_self, PyObject *_args)

   154 {

   155 	PyObject *_res = NULL;

   156 	float sx;

   157 	float sy;

   158 	if (!PyArg_ParseTuple(_args, "ff",

   159 	                      &sx,

   160 	                      &sy))

   161 		return NULL;

   162 	CGContextScaleCTM(_self->ob_itself,

   163 	                  sx,

   164 	                  sy);

   165 	Py_INCREF(Py_None);

   166 	_res = Py_None;

   167 	return _res;

   168 }

   169 

   170 static PyObject *CGContextRefObj_CGContextTranslateCTM(CGContextRefObject *_self, PyObject *_args)

   171 {

   172 	PyObject *_res = NULL;

   173 	float tx;

   174 	float ty;

   175 	if (!PyArg_ParseTuple(_args, "ff",

   176 	                      &tx,

   177 	                      &ty))

   178 		return NULL;

   179 	CGContextTranslateCTM(_self->ob_itself,

   180 	                      tx,

   181 	                      ty);

   182 	Py_INCREF(Py_None);

   183 	_res = Py_None;

   184 	return _res;

   185 }

   186 

   187 static PyObject *CGContextRefObj_CGContextRotateCTM(CGContextRefObject *_self, PyObject *_args)

   188 {

   189 	PyObject *_res = NULL;

   190 	float angle;

   191 	if (!PyArg_ParseTuple(_args, "f",

   192 	                      &angle))

   193 		return NULL;

   194 	CGContextRotateCTM(_self->ob_itself,

   195 	                   angle);

   196 	Py_INCREF(Py_None);

   197 	_res = Py_None;

   198 	return _res;

   199 }

   200 

   201 static PyObject *CGContextRefObj_CGContextConcatCTM(CGContextRefObject *_self, PyObject *_args)

   202 {

   203 	PyObject *_res = NULL;

   204 	CGAffineTransform transform;

   205 	if (!PyArg_ParseTuple(_args, "O&",

   206 	                      CGAffineTransform_Convert, &transform))

   207 		return NULL;

   208 	CGContextConcatCTM(_self->ob_itself,

   209 	                   transform);

   210 	Py_INCREF(Py_None);

   211 	_res = Py_None;

   212 	return _res;

   213 }

   214 

   215 static PyObject *CGContextRefObj_CGContextGetCTM(CGContextRefObject *_self, PyObject *_args)

   216 {

   217 	PyObject *_res = NULL;

   218 	CGAffineTransform _rv;

   219 	if (!PyArg_ParseTuple(_args, ""))

   220 		return NULL;

   221 	_rv = CGContextGetCTM(_self->ob_itself);

   222 	_res = Py_BuildValue("O&",

   223 	                     CGAffineTransform_New, &_rv);

   224 	return _res;

   225 }

   226 

   227 static PyObject *CGContextRefObj_CGContextSetLineWidth(CGContextRefObject *_self, PyObject *_args)

   228 {

   229 	PyObject *_res = NULL;

   230 	float width;

   231 	if (!PyArg_ParseTuple(_args, "f",

   232 	                      &width))

   233 		return NULL;

   234 	CGContextSetLineWidth(_self->ob_itself,

   235 	                      width);

   236 	Py_INCREF(Py_None);

   237 	_res = Py_None;

   238 	return _res;

   239 }

   240 

   241 static PyObject *CGContextRefObj_CGContextSetLineCap(CGContextRefObject *_self, PyObject *_args)

   242 {

   243 	PyObject *_res = NULL;

   244 	int cap;

   245 	if (!PyArg_ParseTuple(_args, "i",

   246 	                      &cap))

   247 		return NULL;

   248 	CGContextSetLineCap(_self->ob_itself,

   249 	                    cap);

   250 	Py_INCREF(Py_None);

   251 	_res = Py_None;

   252 	return _res;

   253 }

   254 

   255 static PyObject *CGContextRefObj_CGContextSetLineJoin(CGContextRefObject *_self, PyObject *_args)

   256 {

   257 	PyObject *_res = NULL;

   258 	int join;

   259 	if (!PyArg_ParseTuple(_args, "i",

   260 	                      &join))

   261 		return NULL;

   262 	CGContextSetLineJoin(_self->ob_itself,

   263 	                     join);

   264 	Py_INCREF(Py_None);

   265 	_res = Py_None;

   266 	return _res;

   267 }

   268 

   269 static PyObject *CGContextRefObj_CGContextSetMiterLimit(CGContextRefObject *_self, PyObject *_args)

   270 {

   271 	PyObject *_res = NULL;

   272 	float limit;

   273 	if (!PyArg_ParseTuple(_args, "f",

   274 	                      &limit))

   275 		return NULL;

   276 	CGContextSetMiterLimit(_self->ob_itself,

   277 	                       limit);

   278 	Py_INCREF(Py_None);

   279 	_res = Py_None;

   280 	return _res;

   281 }

   282 

   283 static PyObject *CGContextRefObj_CGContextSetFlatness(CGContextRefObject *_self, PyObject *_args)

   284 {

   285 	PyObject *_res = NULL;

   286 	float flatness;

   287 	if (!PyArg_ParseTuple(_args, "f",

   288 	                      &flatness))

   289 		return NULL;

   290 	CGContextSetFlatness(_self->ob_itself,

   291 	                     flatness);

   292 	Py_INCREF(Py_None);

   293 	_res = Py_None;

   294 	return _res;

   295 }

   296 

   297 static PyObject *CGContextRefObj_CGContextSetAlpha(CGContextRefObject *_self, PyObject *_args)

   298 {

   299 	PyObject *_res = NULL;

   300 	float alpha;

   301 	if (!PyArg_ParseTuple(_args, "f",

   302 	                      &alpha))

   303 		return NULL;

   304 	CGContextSetAlpha(_self->ob_itself,

   305 	                  alpha);

   306 	Py_INCREF(Py_None);

   307 	_res = Py_None;

   308 	return _res;

   309 }

   310 

   311 static PyObject *CGContextRefObj_CGContextBeginPath(CGContextRefObject *_self, PyObject *_args)

   312 {

   313 	PyObject *_res = NULL;

   314 	if (!PyArg_ParseTuple(_args, ""))

   315 		return NULL;

   316 	CGContextBeginPath(_self->ob_itself);

   317 	Py_INCREF(Py_None);

   318 	_res = Py_None;

   319 	return _res;

   320 }

   321 

   322 static PyObject *CGContextRefObj_CGContextMoveToPoint(CGContextRefObject *_self, PyObject *_args)

   323 {

   324 	PyObject *_res = NULL;

   325 	float x;

   326 	float y;

   327 	if (!PyArg_ParseTuple(_args, "ff",

   328 	                      &x,

   329 	                      &y))

   330 		return NULL;

   331 	CGContextMoveToPoint(_self->ob_itself,

   332 	                     x,

   333 	                     y);

   334 	Py_INCREF(Py_None);

   335 	_res = Py_None;

   336 	return _res;

   337 }

   338 

   339 static PyObject *CGContextRefObj_CGContextAddLineToPoint(CGContextRefObject *_self, PyObject *_args)

   340 {

   341 	PyObject *_res = NULL;

   342 	float x;

   343 	float y;

   344 	if (!PyArg_ParseTuple(_args, "ff",

   345 	                      &x,

   346 	                      &y))

   347 		return NULL;

   348 	CGContextAddLineToPoint(_self->ob_itself,

   349 	                        x,

   350 	                        y);

   351 	Py_INCREF(Py_None);

   352 	_res = Py_None;

   353 	return _res;

   354 }

   355 

   356 static PyObject *CGContextRefObj_CGContextAddCurveToPoint(CGContextRefObject *_self, PyObject *_args)

   357 {

   358 	PyObject *_res = NULL;

   359 	float cp1x;

   360 	float cp1y;

   361 	float cp2x;

   362 	float cp2y;

   363 	float x;

   364 	float y;

   365 	if (!PyArg_ParseTuple(_args, "ffffff",

   366 	                      &cp1x,

   367 	                      &cp1y,

   368 	                      &cp2x,

   369 	                      &cp2y,

   370 	                      &x,

   371 	                      &y))

   372 		return NULL;

   373 	CGContextAddCurveToPoint(_self->ob_itself,

   374 	                         cp1x,

   375 	                         cp1y,

   376 	                         cp2x,

   377 	                         cp2y,

   378 	                         x,

   379 	                         y);

   380 	Py_INCREF(Py_None);

   381 	_res = Py_None;

   382 	return _res;

   383 }

   384 

   385 static PyObject *CGContextRefObj_CGContextAddQuadCurveToPoint(CGContextRefObject *_self, PyObject *_args)

   386 {

   387 	PyObject *_res = NULL;

   388 	float cpx;

   389 	float cpy;

   390 	float x;

   391 	float y;

   392 	if (!PyArg_ParseTuple(_args, "ffff",

   393 	                      &cpx,

   394 	                      &cpy,

   395 	                      &x,

   396 	                      &y))

   397 		return NULL;

   398 	CGContextAddQuadCurveToPoint(_self->ob_itself,

   399 	                             cpx,

   400 	                             cpy,

   401 	                             x,

   402 	                             y);

   403 	Py_INCREF(Py_None);

   404 	_res = Py_None;

   405 	return _res;

   406 }

   407 

   408 static PyObject *CGContextRefObj_CGContextClosePath(CGContextRefObject *_self, PyObject *_args)

   409 {

   410 	PyObject *_res = NULL;

   411 	if (!PyArg_ParseTuple(_args, ""))

   412 		return NULL;

   413 	CGContextClosePath(_self->ob_itself);

   414 	Py_INCREF(Py_None);

   415 	_res = Py_None;

   416 	return _res;

   417 }

   418 

   419 static PyObject *CGContextRefObj_CGContextAddRect(CGContextRefObject *_self, PyObject *_args)

   420 {

   421 	PyObject *_res = NULL;

   422 	CGRect rect;

   423 	if (!PyArg_ParseTuple(_args, "O&",

   424 	                      CGRect_Convert, &rect))

   425 		return NULL;

   426 	CGContextAddRect(_self->ob_itself,

   427 	                 rect);

   428 	Py_INCREF(Py_None);

   429 	_res = Py_None;

   430 	return _res;

   431 }

   432 

   433 static PyObject *CGContextRefObj_CGContextAddArc(CGContextRefObject *_self, PyObject *_args)

   434 {

   435 	PyObject *_res = NULL;

   436 	float x;

   437 	float y;

   438 	float radius;

   439 	float startAngle;

   440 	float endAngle;

   441 	int clockwise;

   442 	if (!PyArg_ParseTuple(_args, "fffffi",

   443 	                      &x,

   444 	                      &y,

   445 	                      &radius,

   446 	                      &startAngle,

   447 	                      &endAngle,

   448 	                      &clockwise))

   449 		return NULL;

   450 	CGContextAddArc(_self->ob_itself,

   451 	                x,

   452 	                y,

   453 	                radius,

   454 	                startAngle,

   455 	                endAngle,

   456 	                clockwise);

   457 	Py_INCREF(Py_None);

   458 	_res = Py_None;

   459 	return _res;

   460 }

   461 

   462 static PyObject *CGContextRefObj_CGContextAddArcToPoint(CGContextRefObject *_self, PyObject *_args)

   463 {

   464 	PyObject *_res = NULL;

   465 	float x1;

   466 	float y1;

   467 	float x2;

   468 	float y2;

   469 	float radius;

   470 	if (!PyArg_ParseTuple(_args, "fffff",

   471 	                      &x1,

   472 	                      &y1,

   473 	                      &x2,

   474 	                      &y2,

   475 	                      &radius))

   476 		return NULL;

   477 	CGContextAddArcToPoint(_self->ob_itself,

   478 	                       x1,

   479 	                       y1,

   480 	                       x2,

   481 	                       y2,

   482 	                       radius);

   483 	Py_INCREF(Py_None);

   484 	_res = Py_None;

   485 	return _res;

   486 }

   487 

   488 static PyObject *CGContextRefObj_CGContextIsPathEmpty(CGContextRefObject *_self, PyObject *_args)

   489 {

   490 	PyObject *_res = NULL;

   491 	int _rv;

   492 	if (!PyArg_ParseTuple(_args, ""))

   493 		return NULL;

   494 	_rv = CGContextIsPathEmpty(_self->ob_itself);

   495 	_res = Py_BuildValue("i",

   496 	                     _rv);

   497 	return _res;

   498 }

   499 

   500 static PyObject *CGContextRefObj_CGContextGetPathCurrentPoint(CGContextRefObject *_self, PyObject *_args)

   501 {

   502 	PyObject *_res = NULL;

   503 	CGPoint _rv;

   504 	if (!PyArg_ParseTuple(_args, ""))

   505 		return NULL;

   506 	_rv = CGContextGetPathCurrentPoint(_self->ob_itself);

   507 	_res = Py_BuildValue("O&",

   508 	                     CGPoint_New, &_rv);

   509 	return _res;

   510 }

   511 

   512 static PyObject *CGContextRefObj_CGContextGetPathBoundingBox(CGContextRefObject *_self, PyObject *_args)

   513 {

   514 	PyObject *_res = NULL;

   515 	CGRect _rv;

   516 	if (!PyArg_ParseTuple(_args, ""))

   517 		return NULL;

   518 	_rv = CGContextGetPathBoundingBox(_self->ob_itself);

   519 	_res = Py_BuildValue("O&",

   520 	                     CGRect_New, &_rv);

   521 	return _res;

   522 }

   523 

   524 static PyObject *CGContextRefObj_CGContextDrawPath(CGContextRefObject *_self, PyObject *_args)

   525 {

   526 	PyObject *_res = NULL;

   527 	int mode;

   528 	if (!PyArg_ParseTuple(_args, "i",

   529 	                      &mode))

   530 		return NULL;

   531 	CGContextDrawPath(_self->ob_itself,

   532 	                  mode);

   533 	Py_INCREF(Py_None);

   534 	_res = Py_None;

   535 	return _res;

   536 }

   537 

   538 static PyObject *CGContextRefObj_CGContextFillPath(CGContextRefObject *_self, PyObject *_args)

   539 {

   540 	PyObject *_res = NULL;

   541 	if (!PyArg_ParseTuple(_args, ""))

   542 		return NULL;

   543 	CGContextFillPath(_self->ob_itself);

   544 	Py_INCREF(Py_None);

   545 	_res = Py_None;

   546 	return _res;

   547 }

   548 

   549 static PyObject *CGContextRefObj_CGContextEOFillPath(CGContextRefObject *_self, PyObject *_args)

   550 {

   551 	PyObject *_res = NULL;

   552 	if (!PyArg_ParseTuple(_args, ""))

   553 		return NULL;

   554 	CGContextEOFillPath(_self->ob_itself);

   555 	Py_INCREF(Py_None);

   556 	_res = Py_None;

   557 	return _res;

   558 }

   559 

   560 static PyObject *CGContextRefObj_CGContextStrokePath(CGContextRefObject *_self, PyObject *_args)

   561 {

   562 	PyObject *_res = NULL;

   563 	if (!PyArg_ParseTuple(_args, ""))

   564 		return NULL;

   565 	CGContextStrokePath(_self->ob_itself);

   566 	Py_INCREF(Py_None);

   567 	_res = Py_None;

   568 	return _res;

   569 }

   570 

   571 static PyObject *CGContextRefObj_CGContextFillRect(CGContextRefObject *_self, PyObject *_args)

   572 {

   573 	PyObject *_res = NULL;

   574 	CGRect rect;

   575 	if (!PyArg_ParseTuple(_args, "O&",

   576 	                      CGRect_Convert, &rect))

   577 		return NULL;

   578 	CGContextFillRect(_self->ob_itself,

   579 	                  rect);

   580 	Py_INCREF(Py_None);

   581 	_res = Py_None;

   582 	return _res;

   583 }

   584 

   585 static PyObject *CGContextRefObj_CGContextStrokeRect(CGContextRefObject *_self, PyObject *_args)

   586 {

   587 	PyObject *_res = NULL;

   588 	CGRect rect;

   589 	if (!PyArg_ParseTuple(_args, "O&",

   590 	                      CGRect_Convert, &rect))

   591 		return NULL;

   592 	CGContextStrokeRect(_self->ob_itself,

   593 	                    rect);

   594 	Py_INCREF(Py_None);

   595 	_res = Py_None;

   596 	return _res;

   597 }

   598 

   599 static PyObject *CGContextRefObj_CGContextStrokeRectWithWidth(CGContextRefObject *_self, PyObject *_args)

   600 {

   601 	PyObject *_res = NULL;

   602 	CGRect rect;

   603 	float width;

   604 	if (!PyArg_ParseTuple(_args, "O&f",

   605 	                      CGRect_Convert, &rect,

   606 	                      &width))

   607 		return NULL;

   608 	CGContextStrokeRectWithWidth(_self->ob_itself,

   609 	                             rect,

   610 	                             width);

   611 	Py_INCREF(Py_None);

   612 	_res = Py_None;

   613 	return _res;

   614 }

   615 

   616 static PyObject *CGContextRefObj_CGContextClearRect(CGContextRefObject *_self, PyObject *_args)

   617 {

   618 	PyObject *_res = NULL;

   619 	CGRect rect;

   620 	if (!PyArg_ParseTuple(_args, "O&",

   621 	                      CGRect_Convert, &rect))

   622 		return NULL;

   623 	CGContextClearRect(_self->ob_itself,

   624 	                   rect);

   625 	Py_INCREF(Py_None);

   626 	_res = Py_None;

   627 	return _res;

   628 }

   629 

   630 static PyObject *CGContextRefObj_CGContextClip(CGContextRefObject *_self, PyObject *_args)

   631 {

   632 	PyObject *_res = NULL;

   633 	if (!PyArg_ParseTuple(_args, ""))

   634 		return NULL;

   635 	CGContextClip(_self->ob_itself);

   636 	Py_INCREF(Py_None);

   637 	_res = Py_None;

   638 	return _res;

   639 }

   640 

   641 static PyObject *CGContextRefObj_CGContextEOClip(CGContextRefObject *_self, PyObject *_args)

   642 {

   643 	PyObject *_res = NULL;

   644 	if (!PyArg_ParseTuple(_args, ""))

   645 		return NULL;

   646 	CGContextEOClip(_self->ob_itself);

   647 	Py_INCREF(Py_None);

   648 	_res = Py_None;

   649 	return _res;

   650 }

   651 

   652 static PyObject *CGContextRefObj_CGContextClipToRect(CGContextRefObject *_self, PyObject *_args)

   653 {

   654 	PyObject *_res = NULL;

   655 	CGRect rect;

   656 	if (!PyArg_ParseTuple(_args, "O&",

   657 	                      CGRect_Convert, &rect))

   658 		return NULL;

   659 	CGContextClipToRect(_self->ob_itself,

   660 	                    rect);

   661 	Py_INCREF(Py_None);

   662 	_res = Py_None;

   663 	return _res;

   664 }

   665 

   666 static PyObject *CGContextRefObj_CGContextSetGrayFillColor(CGContextRefObject *_self, PyObject *_args)

   667 {

   668 	PyObject *_res = NULL;

   669 	float gray;

   670 	float alpha;

   671 	if (!PyArg_ParseTuple(_args, "ff",

   672 	                      &gray,

   673 	                      &alpha))

   674 		return NULL;

   675 	CGContextSetGrayFillColor(_self->ob_itself,

   676 	                          gray,

   677 	                          alpha);

   678 	Py_INCREF(Py_None);

   679 	_res = Py_None;

   680 	return _res;

   681 }

   682 

   683 static PyObject *CGContextRefObj_CGContextSetGrayStrokeColor(CGContextRefObject *_self, PyObject *_args)

   684 {

   685 	PyObject *_res = NULL;

   686 	float gray;

   687 	float alpha;

   688 	if (!PyArg_ParseTuple(_args, "ff",

   689 	                      &gray,

   690 	                      &alpha))

   691 		return NULL;

   692 	CGContextSetGrayStrokeColor(_self->ob_itself,

   693 	                            gray,

   694 	                            alpha);

   695 	Py_INCREF(Py_None);

   696 	_res = Py_None;

   697 	return _res;

   698 }

   699 

   700 static PyObject *CGContextRefObj_CGContextSetRGBFillColor(CGContextRefObject *_self, PyObject *_args)

   701 {

   702 	PyObject *_res = NULL;

   703 	float red;

   704 	float green;

   705 	float blue;

   706 	float alpha;

   707 	if (!PyArg_ParseTuple(_args, "ffff",

   708 	                      &red,

   709 	                      &green,

   710 	                      &blue,

   711 	                      &alpha))

   712 		return NULL;

   713 	CGContextSetRGBFillColor(_self->ob_itself,

   714 	                         red,

   715 	                         green,

   716 	                         blue,

   717 	                         alpha);

   718 	Py_INCREF(Py_None);

   719 	_res = Py_None;

   720 	return _res;

   721 }

   722 

   723 static PyObject *CGContextRefObj_CGContextSetRGBStrokeColor(CGContextRefObject *_self, PyObject *_args)

   724 {

   725 	PyObject *_res = NULL;

   726 	float red;

   727 	float green;

   728 	float blue;

   729 	float alpha;

   730 	if (!PyArg_ParseTuple(_args, "ffff",

   731 	                      &red,

   732 	                      &green,

   733 	                      &blue,

   734 	                      &alpha))

   735 		return NULL;

   736 	CGContextSetRGBStrokeColor(_self->ob_itself,

   737 	                           red,

   738 	                           green,

   739 	                           blue,

   740 	                           alpha);

   741 	Py_INCREF(Py_None);

   742 	_res = Py_None;

   743 	return _res;

   744 }

   745 

   746 static PyObject *CGContextRefObj_CGContextSetCMYKFillColor(CGContextRefObject *_self, PyObject *_args)

   747 {

   748 	PyObject *_res = NULL;

   749 	float cyan;

   750 	float magenta;

   751 	float yellow;

   752 	float black;

   753 	float alpha;

   754 	if (!PyArg_ParseTuple(_args, "fffff",

   755 	                      &cyan,

   756 	                      &magenta,

   757 	                      &yellow,

   758 	                      &black,

   759 	                      &alpha))

   760 		return NULL;

   761 	CGContextSetCMYKFillColor(_self->ob_itself,

   762 	                          cyan,

   763 	                          magenta,

   764 	                          yellow,

   765 	                          black,

   766 	                          alpha);

   767 	Py_INCREF(Py_None);

   768 	_res = Py_None;

   769 	return _res;

   770 }

   771 

   772 static PyObject *CGContextRefObj_CGContextSetCMYKStrokeColor(CGContextRefObject *_self, PyObject *_args)

   773 {

   774 	PyObject *_res = NULL;

   775 	float cyan;

   776 	float magenta;

   777 	float yellow;

   778 	float black;

   779 	float alpha;

   780 	if (!PyArg_ParseTuple(_args, "fffff",

   781 	                      &cyan,

   782 	                      &magenta,

   783 	                      &yellow,

   784 	                      &black,

   785 	                      &alpha))

   786 		return NULL;

   787 	CGContextSetCMYKStrokeColor(_self->ob_itself,

   788 	                            cyan,

   789 	                            magenta,

   790 	                            yellow,

   791 	                            black,

   792 	                            alpha);

   793 	Py_INCREF(Py_None);

   794 	_res = Py_None;

   795 	return _res;

   796 }

   797 

   798 static PyObject *CGContextRefObj_CGContextGetInterpolationQuality(CGContextRefObject *_self, PyObject *_args)

   799 {

   800 	PyObject *_res = NULL;

   801 	int _rv;

   802 	if (!PyArg_ParseTuple(_args, ""))

   803 		return NULL;

   804 	_rv = CGContextGetInterpolationQuality(_self->ob_itself);

   805 	_res = Py_BuildValue("i",

   806 	                     _rv);

   807 	return _res;

   808 }

   809 

   810 static PyObject *CGContextRefObj_CGContextSetInterpolationQuality(CGContextRefObject *_self, PyObject *_args)

   811 {

   812 	PyObject *_res = NULL;

   813 	int quality;

   814 	if (!PyArg_ParseTuple(_args, "i",

   815 	                      &quality))

   816 		return NULL;

   817 	CGContextSetInterpolationQuality(_self->ob_itself,

   818 	                                 quality);

   819 	Py_INCREF(Py_None);

   820 	_res = Py_None;

   821 	return _res;

   822 }

   823 

   824 static PyObject *CGContextRefObj_CGContextSetCharacterSpacing(CGContextRefObject *_self, PyObject *_args)

   825 {

   826 	PyObject *_res = NULL;

   827 	float spacing;

   828 	if (!PyArg_ParseTuple(_args, "f",

   829 	                      &spacing))

   830 		return NULL;

   831 	CGContextSetCharacterSpacing(_self->ob_itself,

   832 	                             spacing);

   833 	Py_INCREF(Py_None);

   834 	_res = Py_None;

   835 	return _res;

   836 }

   837 

   838 static PyObject *CGContextRefObj_CGContextSetTextPosition(CGContextRefObject *_self, PyObject *_args)

   839 {

   840 	PyObject *_res = NULL;

   841 	float x;

   842 	float y;

   843 	if (!PyArg_ParseTuple(_args, "ff",

   844 	                      &x,

   845 	                      &y))

   846 		return NULL;

   847 	CGContextSetTextPosition(_self->ob_itself,

   848 	                         x,

   849 	                         y);

   850 	Py_INCREF(Py_None);

   851 	_res = Py_None;

   852 	return _res;

   853 }

   854 

   855 static PyObject *CGContextRefObj_CGContextGetTextPosition(CGContextRefObject *_self, PyObject *_args)

   856 {

   857 	PyObject *_res = NULL;

   858 	CGPoint _rv;

   859 	if (!PyArg_ParseTuple(_args, ""))

   860 		return NULL;

   861 	_rv = CGContextGetTextPosition(_self->ob_itself);

   862 	_res = Py_BuildValue("O&",

   863 	                     CGPoint_New, &_rv);

   864 	return _res;

   865 }

   866 

   867 static PyObject *CGContextRefObj_CGContextSetTextMatrix(CGContextRefObject *_self, PyObject *_args)

   868 {

   869 	PyObject *_res = NULL;

   870 	CGAffineTransform transform;

   871 	if (!PyArg_ParseTuple(_args, "O&",

   872 	                      CGAffineTransform_Convert, &transform))

   873 		return NULL;

   874 	CGContextSetTextMatrix(_self->ob_itself,

   875 	                       transform);

   876 	Py_INCREF(Py_None);

   877 	_res = Py_None;

   878 	return _res;

   879 }

   880 

   881 static PyObject *CGContextRefObj_CGContextGetTextMatrix(CGContextRefObject *_self, PyObject *_args)

   882 {

   883 	PyObject *_res = NULL;

   884 	CGAffineTransform _rv;

   885 	if (!PyArg_ParseTuple(_args, ""))

   886 		return NULL;

   887 	_rv = CGContextGetTextMatrix(_self->ob_itself);

   888 	_res = Py_BuildValue("O&",

   889 	                     CGAffineTransform_New, &_rv);

   890 	return _res;

   891 }

   892 

   893 static PyObject *CGContextRefObj_CGContextSetTextDrawingMode(CGContextRefObject *_self, PyObject *_args)

   894 {

   895 	PyObject *_res = NULL;

   896 	int mode;

   897 	if (!PyArg_ParseTuple(_args, "i",

   898 	                      &mode))

   899 		return NULL;

   900 	CGContextSetTextDrawingMode(_self->ob_itself,

   901 	                            mode);

   902 	Py_INCREF(Py_None);

   903 	_res = Py_None;

   904 	return _res;

   905 }

   906 

   907 static PyObject *CGContextRefObj_CGContextSetFontSize(CGContextRefObject *_self, PyObject *_args)

   908 {

   909 	PyObject *_res = NULL;

   910 	float size;

   911 	if (!PyArg_ParseTuple(_args, "f",

   912 	                      &size))

   913 		return NULL;

   914 	CGContextSetFontSize(_self->ob_itself,

   915 	                     size);

   916 	Py_INCREF(Py_None);

   917 	_res = Py_None;

   918 	return _res;

   919 }

   920 

   921 static PyObject *CGContextRefObj_CGContextSelectFont(CGContextRefObject *_self, PyObject *_args)

   922 {

   923 	PyObject *_res = NULL;

   924 	char * name;

   925 	float size;

   926 	int textEncoding;

   927 	if (!PyArg_ParseTuple(_args, "sfi",

   928 	                      &name,

   929 	                      &size,

   930 	                      &textEncoding))

   931 		return NULL;

   932 	CGContextSelectFont(_self->ob_itself,

   933 	                    name,

   934 	                    size,

   935 	                    textEncoding);

   936 	Py_INCREF(Py_None);

   937 	_res = Py_None;

   938 	return _res;

   939 }

   940 

   941 static PyObject *CGContextRefObj_CGContextShowText(CGContextRefObject *_self, PyObject *_args)

   942 {

   943 	PyObject *_res = NULL;

   944 	char *cstring__in__;

   945 	long cstring__len__;

   946 	int cstring__in_len__;

   947 	if (!PyArg_ParseTuple(_args, "s#",

   948 	                      &cstring__in__, &cstring__in_len__))

   949 		return NULL;

   950 	cstring__len__ = cstring__in_len__;

   951 	CGContextShowText(_self->ob_itself,

   952 	                  cstring__in__, cstring__len__);

   953 	Py_INCREF(Py_None);

   954 	_res = Py_None;

   955 	return _res;

   956 }

   957 

   958 static PyObject *CGContextRefObj_CGContextShowTextAtPoint(CGContextRefObject *_self, PyObject *_args)

   959 {

   960 	PyObject *_res = NULL;

   961 	float x;

   962 	float y;

   963 	char *cstring__in__;

   964 	long cstring__len__;

   965 	int cstring__in_len__;

   966 	if (!PyArg_ParseTuple(_args, "ffs#",

   967 	                      &x,

   968 	                      &y,

   969 	                      &cstring__in__, &cstring__in_len__))

   970 		return NULL;

   971 	cstring__len__ = cstring__in_len__;

   972 	CGContextShowTextAtPoint(_self->ob_itself,

   973 	                         x,

   974 	                         y,

   975 	                         cstring__in__, cstring__len__);

   976 	Py_INCREF(Py_None);

   977 	_res = Py_None;

   978 	return _res;

   979 }

   980 

   981 static PyObject *CGContextRefObj_CGContextEndPage(CGContextRefObject *_self, PyObject *_args)

   982 {

   983 	PyObject *_res = NULL;

   984 	if (!PyArg_ParseTuple(_args, ""))

   985 		return NULL;

   986 	CGContextEndPage(_self->ob_itself);

   987 	Py_INCREF(Py_None);

   988 	_res = Py_None;

   989 	return _res;

   990 }

   991 

   992 static PyObject *CGContextRefObj_CGContextFlush(CGContextRefObject *_self, PyObject *_args)

   993 {

   994 	PyObject *_res = NULL;

   995 	if (!PyArg_ParseTuple(_args, ""))

   996 		return NULL;

   997 	CGContextFlush(_self->ob_itself);

   998 	Py_INCREF(Py_None);

   999 	_res = Py_None;

  1000 	return _res;

  1001 }

  1002 

  1003 static PyObject *CGContextRefObj_CGContextSynchronize(CGContextRefObject *_self, PyObject *_args)

  1004 {

  1005 	PyObject *_res = NULL;

  1006 	if (!PyArg_ParseTuple(_args, ""))

  1007 		return NULL;

  1008 	CGContextSynchronize(_self->ob_itself);

  1009 	Py_INCREF(Py_None);

  1010 	_res = Py_None;

  1011 	return _res;

  1012 }

  1013 

  1014 static PyObject *CGContextRefObj_CGContextSetShouldAntialias(CGContextRefObject *_self, PyObject *_args)

  1015 {

  1016 	PyObject *_res = NULL;

  1017 	int shouldAntialias;

  1018 	if (!PyArg_ParseTuple(_args, "i",

  1019 	                      &shouldAntialias))

  1020 		return NULL;

  1021 	CGContextSetShouldAntialias(_self->ob_itself,

  1022 	                            shouldAntialias);

  1023 	Py_INCREF(Py_None);

  1024 	_res = Py_None;

  1025 	return _res;

  1026 }

  1027 

  1028 #ifndef __LP64__

  1029 static PyObject *CGContextRefObj_SyncCGContextOriginWithPort(CGContextRefObject *_self, PyObject *_args)

  1030 {

  1031 	PyObject *_res = NULL;

  1032 	CGrafPtr port;

  1033 	if (!PyArg_ParseTuple(_args, "O&",

  1034 	                      GrafObj_Convert, &port))

  1035 		return NULL;

  1036 	SyncCGContextOriginWithPort(_self->ob_itself,

  1037 	                            port);

  1038 	Py_INCREF(Py_None);

  1039 	_res = Py_None;

  1040 	return _res;

  1041 }

  1042 

  1043 static PyObject *CGContextRefObj_ClipCGContextToRegion(CGContextRefObject *_self, PyObject *_args)

  1044 {

  1045 	PyObject *_res = NULL;

  1046 	Rect portRect;

  1047 	RgnHandle region;

  1048 	if (!PyArg_ParseTuple(_args, "O&O&",

  1049 	                      PyMac_GetRect, &portRect,

  1050 	                      ResObj_Convert, &region))

  1051 		return NULL;

  1052 	ClipCGContextToRegion(_self->ob_itself,

  1053 	                      &portRect,

  1054 	                      region);

  1055 	Py_INCREF(Py_None);

  1056 	_res = Py_None;

  1057 	return _res;

  1058 }

  1059 #endif

  1060 

  1061 static PyMethodDef CGContextRefObj_methods[] = {

  1062 	{"CGContextSaveGState", (PyCFunction)CGContextRefObj_CGContextSaveGState, 1,

  1063 	 PyDoc_STR("() -> None")},

  1064 	{"CGContextRestoreGState", (PyCFunction)CGContextRefObj_CGContextRestoreGState, 1,

  1065 	 PyDoc_STR("() -> None")},

  1066 	{"CGContextScaleCTM", (PyCFunction)CGContextRefObj_CGContextScaleCTM, 1,

  1067 	 PyDoc_STR("(float sx, float sy) -> None")},

  1068 	{"CGContextTranslateCTM", (PyCFunction)CGContextRefObj_CGContextTranslateCTM, 1,

  1069 	 PyDoc_STR("(float tx, float ty) -> None")},

  1070 	{"CGContextRotateCTM", (PyCFunction)CGContextRefObj_CGContextRotateCTM, 1,

  1071 	 PyDoc_STR("(float angle) -> None")},

  1072 	{"CGContextConcatCTM", (PyCFunction)CGContextRefObj_CGContextConcatCTM, 1,

  1073 	 PyDoc_STR("(CGAffineTransform transform) -> None")},

  1074 	{"CGContextGetCTM", (PyCFunction)CGContextRefObj_CGContextGetCTM, 1,

  1075 	 PyDoc_STR("() -> (CGAffineTransform _rv)")},

  1076 	{"CGContextSetLineWidth", (PyCFunction)CGContextRefObj_CGContextSetLineWidth, 1,

  1077 	 PyDoc_STR("(float width) -> None")},

  1078 	{"CGContextSetLineCap", (PyCFunction)CGContextRefObj_CGContextSetLineCap, 1,

  1079 	 PyDoc_STR("(int cap) -> None")},

  1080 	{"CGContextSetLineJoin", (PyCFunction)CGContextRefObj_CGContextSetLineJoin, 1,

  1081 	 PyDoc_STR("(int join) -> None")},

  1082 	{"CGContextSetMiterLimit", (PyCFunction)CGContextRefObj_CGContextSetMiterLimit, 1,

  1083 	 PyDoc_STR("(float limit) -> None")},

  1084 	{"CGContextSetFlatness", (PyCFunction)CGContextRefObj_CGContextSetFlatness, 1,

  1085 	 PyDoc_STR("(float flatness) -> None")},

  1086 	{"CGContextSetAlpha", (PyCFunction)CGContextRefObj_CGContextSetAlpha, 1,

  1087 	 PyDoc_STR("(float alpha) -> None")},

  1088 	{"CGContextBeginPath", (PyCFunction)CGContextRefObj_CGContextBeginPath, 1,

  1089 	 PyDoc_STR("() -> None")},

  1090 	{"CGContextMoveToPoint", (PyCFunction)CGContextRefObj_CGContextMoveToPoint, 1,

  1091 	 PyDoc_STR("(float x, float y) -> None")},

  1092 	{"CGContextAddLineToPoint", (PyCFunction)CGContextRefObj_CGContextAddLineToPoint, 1,

  1093 	 PyDoc_STR("(float x, float y) -> None")},

  1094 	{"CGContextAddCurveToPoint", (PyCFunction)CGContextRefObj_CGContextAddCurveToPoint, 1,

  1095 	 PyDoc_STR("(float cp1x, float cp1y, float cp2x, float cp2y, float x, float y) -> None")},

  1096 	{"CGContextAddQuadCurveToPoint", (PyCFunction)CGContextRefObj_CGContextAddQuadCurveToPoint, 1,

  1097 	 PyDoc_STR("(float cpx, float cpy, float x, float y) -> None")},

  1098 	{"CGContextClosePath", (PyCFunction)CGContextRefObj_CGContextClosePath, 1,

  1099 	 PyDoc_STR("() -> None")},

  1100 	{"CGContextAddRect", (PyCFunction)CGContextRefObj_CGContextAddRect, 1,

  1101 	 PyDoc_STR("(CGRect rect) -> None")},

  1102 	{"CGContextAddArc", (PyCFunction)CGContextRefObj_CGContextAddArc, 1,

  1103 	 PyDoc_STR("(float x, float y, float radius, float startAngle, float endAngle, int clockwise) -> None")},

  1104 	{"CGContextAddArcToPoint", (PyCFunction)CGContextRefObj_CGContextAddArcToPoint, 1,

  1105 	 PyDoc_STR("(float x1, float y1, float x2, float y2, float radius) -> None")},

  1106 	{"CGContextIsPathEmpty", (PyCFunction)CGContextRefObj_CGContextIsPathEmpty, 1,

  1107 	 PyDoc_STR("() -> (int _rv)")},

  1108 	{"CGContextGetPathCurrentPoint", (PyCFunction)CGContextRefObj_CGContextGetPathCurrentPoint, 1,

  1109 	 PyDoc_STR("() -> (CGPoint _rv)")},

  1110 	{"CGContextGetPathBoundingBox", (PyCFunction)CGContextRefObj_CGContextGetPathBoundingBox, 1,

  1111 	 PyDoc_STR("() -> (CGRect _rv)")},

  1112 	{"CGContextDrawPath", (PyCFunction)CGContextRefObj_CGContextDrawPath, 1,

  1113 	 PyDoc_STR("(int mode) -> None")},

  1114 	{"CGContextFillPath", (PyCFunction)CGContextRefObj_CGContextFillPath, 1,

  1115 	 PyDoc_STR("() -> None")},

  1116 	{"CGContextEOFillPath", (PyCFunction)CGContextRefObj_CGContextEOFillPath, 1,

  1117 	 PyDoc_STR("() -> None")},

  1118 	{"CGContextStrokePath", (PyCFunction)CGContextRefObj_CGContextStrokePath, 1,

  1119 	 PyDoc_STR("() -> None")},

  1120 	{"CGContextFillRect", (PyCFunction)CGContextRefObj_CGContextFillRect, 1,

  1121 	 PyDoc_STR("(CGRect rect) -> None")},

  1122 	{"CGContextStrokeRect", (PyCFunction)CGContextRefObj_CGContextStrokeRect, 1,

  1123 	 PyDoc_STR("(CGRect rect) -> None")},

  1124 	{"CGContextStrokeRectWithWidth", (PyCFunction)CGContextRefObj_CGContextStrokeRectWithWidth, 1,

  1125 	 PyDoc_STR("(CGRect rect, float width) -> None")},

  1126 	{"CGContextClearRect", (PyCFunction)CGContextRefObj_CGContextClearRect, 1,

  1127 	 PyDoc_STR("(CGRect rect) -> None")},

  1128 	{"CGContextClip", (PyCFunction)CGContextRefObj_CGContextClip, 1,

  1129 	 PyDoc_STR("() -> None")},

  1130 	{"CGContextEOClip", (PyCFunction)CGContextRefObj_CGContextEOClip, 1,

  1131 	 PyDoc_STR("() -> None")},

  1132 	{"CGContextClipToRect", (PyCFunction)CGContextRefObj_CGContextClipToRect, 1,

  1133 	 PyDoc_STR("(CGRect rect) -> None")},

  1134 	{"CGContextSetGrayFillColor", (PyCFunction)CGContextRefObj_CGContextSetGrayFillColor, 1,

  1135 	 PyDoc_STR("(float gray, float alpha) -> None")},