text: 
  /* =========================== Module _CG =========================== */
  
  #include "Python.h"
  
  
  
  #include "pymactoolbox.h"
  
  /* Macro to test whether a weak-loaded CFM function exists */
  #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
      PyErr_SetString(PyExc_NotImplementedError, \
      "Not available in this shared library/OS version"); \
      return NULL; \
      }} while(0)
  
  
  #include <ApplicationServices/ApplicationServices.h>
  
  extern int GrafObj_Convert(PyObject *, GrafPtr *);
  
  /*
  ** Manual converters
  */
  
  PyObject *CGPoint_New(CGPoint *itself)
  {
  
      return Py_BuildValue("(ff)",
                      itself->x,
                      itself->y);
  }
  
  int
  CGPoint_Convert(PyObject *v, CGPoint *p_itself)
  {
      if( !PyArg_Parse(v, "(ff)",
                      &p_itself->x,
                      &p_itself->y) )
          return 0;
      return 1;
  }
  
  PyObject *CGRect_New(CGRect *itself)
  {
  
      return Py_BuildValue("(ffff)",
                      itself->origin.x,
                      itself->origin.y,
                      itself->size.width,
                      itself->size.height);
  }
  
  int
  CGRect_Convert(PyObject *v, CGRect *p_itself)
  {
      if( !PyArg_Parse(v, "(ffff)",
                      &p_itself->origin.x,
                      &p_itself->origin.y,
                      &p_itself->size.width,
                      &p_itself->size.height) )
          return 0;
      return 1;
  }
  
  PyObject *CGAffineTransform_New(CGAffineTransform *itself)
  {
  
      return Py_BuildValue("(ffffff)",
                      itself->a,
                      itself->b,
                      itself->c,
                      itself->d,
                      itself->tx,
                      itself->ty);
  }
  
  int
  CGAffineTransform_Convert(PyObject *v, CGAffineTransform *p_itself)
  {
      if( !PyArg_Parse(v, "(ffffff)",
                      &p_itself->a,
                      &p_itself->b,
                      &p_itself->c,
                      &p_itself->d,
                      &p_itself->tx,
                      &p_itself->ty) )
          return 0;
      return 1;
  }
  
  static PyObject *CG_Error;
  
  /* -------------------- Object type CGContextRef -------------------- */
  
  PyTypeObject CGContextRef_Type;
  
  #define CGContextRefObj_Check(x) ((x)->ob_type == &CGContextRef_Type || PyObject_TypeCheck((x), &CGContextRef_Type))
  
  typedef struct CGContextRefObject {
      PyObject_HEAD
      CGContextRef ob_itself;
  } CGContextRefObject;
  
  PyObject *CGContextRefObj_New(CGContextRef itself)
  {
      CGContextRefObject *it;
      it = PyObject_NEW(CGContextRefObject, &CGContextRef_Type);
      if (it == NULL) return NULL;
      it->ob_itself = itself;
      return (PyObject *)it;
  }
  
  int CGContextRefObj_Convert(PyObject *v, CGContextRef *p_itself)
  {
      if (!CGContextRefObj_Check(v))
      {
          PyErr_SetString(PyExc_TypeError, "CGContextRef required");
          return 0;
      }
      *p_itself = ((CGContextRefObject *)v)->ob_itself;
      return 1;
  }
  
  static void CGContextRefObj_dealloc(CGContextRefObject *self)
  {
      CGContextRelease(self->ob_itself);
      self->ob_type->tp_free((PyObject *)self);
  }
  
  static PyObject *CGContextRefObj_CGContextSaveGState(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      if (!PyArg_ParseTuple(_args, ""))
          return NULL;
      CGContextSaveGState(_self->ob_itself);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextRestoreGState(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      if (!PyArg_ParseTuple(_args, ""))
          return NULL;
      CGContextRestoreGState(_self->ob_itself);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextScaleCTM(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      float sx;
      float sy;
      if (!PyArg_ParseTuple(_args, "ff",
                            &sx,
                            &sy))
          return NULL;
      CGContextScaleCTM(_self->ob_itself,
                        sx,
                        sy);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextTranslateCTM(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      float tx;
      float ty;
      if (!PyArg_ParseTuple(_args, "ff",
                            &tx,
                            &ty))
          return NULL;
      CGContextTranslateCTM(_self->ob_itself,
                            tx,
                            ty);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextRotateCTM(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      float angle;
      if (!PyArg_ParseTuple(_args, "f",
                            &angle))
          return NULL;
      CGContextRotateCTM(_self->ob_itself,
                         angle);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextConcatCTM(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      CGAffineTransform transform;
      if (!PyArg_ParseTuple(_args, "O&",
                            CGAffineTransform_Convert, &transform))
          return NULL;
      CGContextConcatCTM(_self->ob_itself,
                         transform);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextGetCTM(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      CGAffineTransform _rv;
      if (!PyArg_ParseTuple(_args, ""))
          return NULL;
      _rv = CGContextGetCTM(_self->ob_itself);
      _res = Py_BuildValue("O&",
                           CGAffineTransform_New, &_rv);
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextSetLineWidth(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      float width;
      if (!PyArg_ParseTuple(_args, "f",
                            &width))
          return NULL;
      CGContextSetLineWidth(_self->ob_itself,
                            width);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextSetLineCap(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      int cap;
      if (!PyArg_ParseTuple(_args, "i",
                            &cap))
          return NULL;
      CGContextSetLineCap(_self->ob_itself,
                          cap);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextSetLineJoin(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      int join;
      if (!PyArg_ParseTuple(_args, "i",
                            &join))
          return NULL;
      CGContextSetLineJoin(_self->ob_itself,
                           join);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextSetMiterLimit(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      float limit;
      if (!PyArg_ParseTuple(_args, "f",
                            &limit))
          return NULL;
      CGContextSetMiterLimit(_self->ob_itself,
                             limit);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextSetFlatness(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      float flatness;
      if (!PyArg_ParseTuple(_args, "f",
                            &flatness))
          return NULL;
      CGContextSetFlatness(_self->ob_itself,
                           flatness);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextSetAlpha(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      float alpha;
      if (!PyArg_ParseTuple(_args, "f",
                            &alpha))
          return NULL;
      CGContextSetAlpha(_self->ob_itself,
                        alpha);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextBeginPath(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      if (!PyArg_ParseTuple(_args, ""))
          return NULL;
      CGContextBeginPath(_self->ob_itself);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextMoveToPoint(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      float x;
      float y;
      if (!PyArg_ParseTuple(_args, "ff",
                            &x,
                            &y))
          return NULL;
      CGContextMoveToPoint(_self->ob_itself,
                           x,
                           y);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextAddLineToPoint(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      float x;
      float y;
      if (!PyArg_ParseTuple(_args, "ff",
                            &x,
                            &y))
          return NULL;
      CGContextAddLineToPoint(_self->ob_itself,
                              x,
                              y);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextAddCurveToPoint(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      float cp1x;
      float cp1y;
      float cp2x;
      float cp2y;
      float x;
      float y;
      if (!PyArg_ParseTuple(_args, "ffffff",
                            &cp1x,
                            &cp1y,
                            &cp2x,
                            &cp2y,
                            &x,
                            &y))
          return NULL;
      CGContextAddCurveToPoint(_self->ob_itself,
                               cp1x,
                               cp1y,
                               cp2x,
                               cp2y,
                               x,
                               y);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextAddQuadCurveToPoint(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      float cpx;
      float cpy;
      float x;
      float y;
      if (!PyArg_ParseTuple(_args, "ffff",
                            &cpx,
                            &cpy,
                            &x,
                            &y))
          return NULL;
      CGContextAddQuadCurveToPoint(_self->ob_itself,
                                   cpx,
                                   cpy,
                                   x,
                                   y);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextClosePath(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      if (!PyArg_ParseTuple(_args, ""))
          return NULL;
      CGContextClosePath(_self->ob_itself);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextAddRect(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      CGRect rect;
      if (!PyArg_ParseTuple(_args, "O&",
                            CGRect_Convert, &rect))
          return NULL;
      CGContextAddRect(_self->ob_itself,
                       rect);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextAddArc(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      float x;
      float y;
      float radius;
      float startAngle;
      float endAngle;
      int clockwise;
      if (!PyArg_ParseTuple(_args, "fffffi",
                            &x,
                            &y,
                            &radius,
                            &startAngle,
                            &endAngle,
                            &clockwise))
          return NULL;
      CGContextAddArc(_self->ob_itself,
                      x,
                      y,
                      radius,
                      startAngle,
                      endAngle,
                      clockwise);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextAddArcToPoint(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      float x1;
      float y1;
      float x2;
      float y2;
      float radius;
      if (!PyArg_ParseTuple(_args, "fffff",
                            &x1,
                            &y1,
                            &x2,
                            &y2,
                            &radius))
          return NULL;
      CGContextAddArcToPoint(_self->ob_itself,
                             x1,
                             y1,
                             x2,
                             y2,
                             radius);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextIsPathEmpty(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      int _rv;
      if (!PyArg_ParseTuple(_args, ""))
          return NULL;
      _rv = CGContextIsPathEmpty(_self->ob_itself);
      _res = Py_BuildValue("i",
                           _rv);
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextGetPathCurrentPoint(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      CGPoint _rv;
      if (!PyArg_ParseTuple(_args, ""))
          return NULL;
      _rv = CGContextGetPathCurrentPoint(_self->ob_itself);
      _res = Py_BuildValue("O&",
                           CGPoint_New, &_rv);
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextGetPathBoundingBox(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      CGRect _rv;
      if (!PyArg_ParseTuple(_args, ""))
          return NULL;
      _rv = CGContextGetPathBoundingBox(_self->ob_itself);
      _res = Py_BuildValue("O&",
                           CGRect_New, &_rv);
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextDrawPath(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      int mode;
      if (!PyArg_ParseTuple(_args, "i",
                            &mode))
          return NULL;
      CGContextDrawPath(_self->ob_itself,
                        mode);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextFillPath(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      if (!PyArg_ParseTuple(_args, ""))
          return NULL;
      CGContextFillPath(_self->ob_itself);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextEOFillPath(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      if (!PyArg_ParseTuple(_args, ""))
          return NULL;
      CGContextEOFillPath(_self->ob_itself);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextStrokePath(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      if (!PyArg_ParseTuple(_args, ""))
          return NULL;
      CGContextStrokePath(_self->ob_itself);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextFillRect(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      CGRect rect;
      if (!PyArg_ParseTuple(_args, "O&",
                            CGRect_Convert, &rect))
          return NULL;
      CGContextFillRect(_self->ob_itself,
                        rect);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextStrokeRect(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      CGRect rect;
      if (!PyArg_ParseTuple(_args, "O&",
                            CGRect_Convert, &rect))
          return NULL;
      CGContextStrokeRect(_self->ob_itself,
                          rect);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextStrokeRectWithWidth(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      CGRect rect;
      float width;
      if (!PyArg_ParseTuple(_args, "O&f",
                            CGRect_Convert, &rect,
                            &width))
          return NULL;
      CGContextStrokeRectWithWidth(_self->ob_itself,
                                   rect,
                                   width);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextClearRect(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      CGRect rect;
      if (!PyArg_ParseTuple(_args, "O&",
                            CGRect_Convert, &rect))
          return NULL;
      CGContextClearRect(_self->ob_itself,
                         rect);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextClip(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      if (!PyArg_ParseTuple(_args, ""))
          return NULL;
      CGContextClip(_self->ob_itself);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextEOClip(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      if (!PyArg_ParseTuple(_args, ""))
          return NULL;
      CGContextEOClip(_self->ob_itself);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextClipToRect(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      CGRect rect;
      if (!PyArg_ParseTuple(_args, "O&",
                            CGRect_Convert, &rect))
          return NULL;
      CGContextClipToRect(_self->ob_itself,
                          rect);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextSetGrayFillColor(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      float gray;
      float alpha;
      if (!PyArg_ParseTuple(_args, "ff",
                            &gray,
                            &alpha))
          return NULL;
      CGContextSetGrayFillColor(_self->ob_itself,
                                gray,
                                alpha);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextSetGrayStrokeColor(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      float gray;
      float alpha;
      if (!PyArg_ParseTuple(_args, "ff",
                            &gray,
                            &alpha))
          return NULL;
      CGContextSetGrayStrokeColor(_self->ob_itself,
                                  gray,
                                  alpha);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextSetRGBFillColor(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      float red;
      float green;
      float blue;
      float alpha;
      if (!PyArg_ParseTuple(_args, "ffff",
                            &red,
                            &green,
                            &blue,
                            &alpha))
          return NULL;
      CGContextSetRGBFillColor(_self->ob_itself,
                               red,
                               green,
                               blue,
                               alpha);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextSetRGBStrokeColor(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      float red;
      float green;
      float blue;
      float alpha;
      if (!PyArg_ParseTuple(_args, "ffff",
                            &red,
                            &green,
                            &blue,
                            &alpha))
          return NULL;
      CGContextSetRGBStrokeColor(_self->ob_itself,
                                 red,
                                 green,
                                 blue,
                                 alpha);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextSetCMYKFillColor(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      float cyan;
      float magenta;
      float yellow;
      float black;
      float alpha;
      if (!PyArg_ParseTuple(_args, "fffff",
                            &cyan,
                            &magenta,
                            &yellow,
                            &black,
                            &alpha))
          return NULL;
      CGContextSetCMYKFillColor(_self->ob_itself,
                                cyan,
                                magenta,
                                yellow,
                                black,
                                alpha);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextSetCMYKStrokeColor(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      float cyan;
      float magenta;
      float yellow;
      float black;
      float alpha;
      if (!PyArg_ParseTuple(_args, "fffff",
                            &cyan,
                            &magenta,
                            &yellow,
                            &black,
                            &alpha))
          return NULL;
      CGContextSetCMYKStrokeColor(_self->ob_itself,
                                  cyan,
                                  magenta,
                                  yellow,
                                  black,
                                  alpha);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextGetInterpolationQuality(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      int _rv;
      if (!PyArg_ParseTuple(_args, ""))
          return NULL;
      _rv = CGContextGetInterpolationQuality(_self->ob_itself);
      _res = Py_BuildValue("i",
                           _rv);
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextSetInterpolationQuality(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      int quality;
      if (!PyArg_ParseTuple(_args, "i",
                            &quality))
          return NULL;
      CGContextSetInterpolationQuality(_self->ob_itself,
                                       quality);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextSetCharacterSpacing(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      float spacing;
      if (!PyArg_ParseTuple(_args, "f",
                            &spacing))
          return NULL;
      CGContextSetCharacterSpacing(_self->ob_itself,
                                   spacing);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextSetTextPosition(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      float x;
      float y;
      if (!PyArg_ParseTuple(_args, "ff",
                            &x,
                            &y))
          return NULL;
      CGContextSetTextPosition(_self->ob_itself,
                               x,
                               y);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextGetTextPosition(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      CGPoint _rv;
      if (!PyArg_ParseTuple(_args, ""))
          return NULL;
      _rv = CGContextGetTextPosition(_self->ob_itself);
      _res = Py_BuildValue("O&",
                           CGPoint_New, &_rv);
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextSetTextMatrix(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      CGAffineTransform transform;
      if (!PyArg_ParseTuple(_args, "O&",
                            CGAffineTransform_Convert, &transform))
          return NULL;
      CGContextSetTextMatrix(_self->ob_itself,
                             transform);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextGetTextMatrix(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      CGAffineTransform _rv;
      if (!PyArg_ParseTuple(_args, ""))
          return NULL;
      _rv = CGContextGetTextMatrix(_self->ob_itself);
      _res = Py_BuildValue("O&",
                           CGAffineTransform_New, &_rv);
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextSetTextDrawingMode(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      int mode;
      if (!PyArg_ParseTuple(_args, "i",
                            &mode))
          return NULL;
      CGContextSetTextDrawingMode(_self->ob_itself,
                                  mode);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextSetFontSize(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      float size;
      if (!PyArg_ParseTuple(_args, "f",
                            &size))
          return NULL;
      CGContextSetFontSize(_self->ob_itself,
                           size);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextSelectFont(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      char * name;
      float size;
      int textEncoding;
      if (!PyArg_ParseTuple(_args, "sfi",
                            &name,
                            &size,
                            &textEncoding))
          return NULL;
      CGContextSelectFont(_self->ob_itself,
                          name,
                          size,
                          textEncoding);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextShowText(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      char *cstring__in__;
      long cstring__len__;
      int cstring__in_len__;
      if (!PyArg_ParseTuple(_args, "s#",
                            &cstring__in__, &cstring__in_len__))
          return NULL;
      cstring__len__ = cstring__in_len__;
      CGContextShowText(_self->ob_itself,
                        cstring__in__, cstring__len__);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextShowTextAtPoint(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      float x;
      float y;
      char *cstring__in__;
      long cstring__len__;
      int cstring__in_len__;
      if (!PyArg_ParseTuple(_args, "ffs#",
                            &x,
                            &y,
                            &cstring__in__, &cstring__in_len__))
          return NULL;
      cstring__len__ = cstring__in_len__;
      CGContextShowTextAtPoint(_self->ob_itself,
                               x,
                               y,
                               cstring__in__, cstring__len__);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextEndPage(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      if (!PyArg_ParseTuple(_args, ""))
          return NULL;
      CGContextEndPage(_self->ob_itself);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextFlush(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      if (!PyArg_ParseTuple(_args, ""))
          return NULL;
      CGContextFlush(_self->ob_itself);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextSynchronize(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      if (!PyArg_ParseTuple(_args, ""))
          return NULL;
      CGContextSynchronize(_self->ob_itself);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_CGContextSetShouldAntialias(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      int shouldAntialias;
      if (!PyArg_ParseTuple(_args, "i",
                            &shouldAntialias))
          return NULL;
      CGContextSetShouldAntialias(_self->ob_itself,
                                  shouldAntialias);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  #ifndef __LP64__
  static PyObject *CGContextRefObj_SyncCGContextOriginWithPort(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      CGrafPtr port;
      if (!PyArg_ParseTuple(_args, "O&",
                            GrafObj_Convert, &port))
          return NULL;
      SyncCGContextOriginWithPort(_self->ob_itself,
                                  port);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  
  static PyObject *CGContextRefObj_ClipCGContextToRegion(CGContextRefObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      Rect portRect;
      RgnHandle region;
      if (!PyArg_ParseTuple(_args, "O&O&",
                            PyMac_GetRect, &portRect,
                            ResObj_Convert, &region))
          return NULL;
      ClipCGContextToRegion(_self->ob_itself,
                            &portRect,
                            region);
      Py_INCREF(Py_Nil);
      _res = Py_Nil;
      return _res;
  }
  #endif
  
  static PyMethodDef CGContextRefObj_methods[] = {
      {"CGContextSaveGState", (PyCFunction)CGContextRefObj_CGContextSaveGState, 1,
       PyDoc_STR("() -> None")},
      {"CGContextRestoreGState", (PyCFunction)CGContextRefObj_CGContextRestoreGState, 1,
       PyDoc_STR("() -> None")},
      {"CGContextScaleCTM", (PyCFunction)CGContextRefObj_CGContextScaleCTM, 1,
       PyDoc_STR("(float sx, float sy) -> None")},
      {"CGContextTranslateCTM", (PyCFunction)CGContextRefObj_CGContextTranslateCTM, 1,
       PyDoc_STR("(float tx, float ty) -> None")},
      {"CGContextRotateCTM", (PyCFunction)CGContextRefObj_CGContextRotateCTM, 1,
       PyDoc_STR("(float angle) -> None")},
      {"CGContextConcatCTM", (PyCFunction)CGContextRefObj_CGContextConcatCTM, 1,
       PyDoc_STR("(CGAffineTransform transform) -> None")},
      {"CGContextGetCTM", (PyCFunction)CGContextRefObj_CGContextGetCTM, 1,
       PyDoc_STR("() -> (CGAffineTransform _rv)")},
      {"CGContextSetLineWidth", (PyCFunction)CGContextRefObj_CGContextSetLineWidth, 1,
       PyDoc_STR("(float width) -> None")},
      {"CGContextSetLineCap", (PyCFunction)CGContextRefObj_CGContextSetLineCap, 1,
       PyDoc_STR("(int cap) -> None")},
      {"CGContextSetLineJoin", (PyCFunction)CGContextRefObj_CGContextSetLineJoin, 1,
       PyDoc_STR("(int join) -> None")},
      {"CGContextSetMiterLimit", (PyCFunction)CGContextRefObj_CGContextSetMiterLimit, 1,
       PyDoc_STR("(float limit) -> None")},
      {"CGContextSetFlatness", (PyCFunction)CGContextRefObj_CGContextSetFlatness, 1,
       PyDoc_STR("(float flatness) -> None")},
      {"CGContextSetAlpha", (PyCFunction)CGContextRefObj_CGContextSetAlpha, 1,
       PyDoc_STR("(float alpha) -> None")},
      {"CGContextBeginPath", (PyCFunction)CGContextRefObj_CGContextBeginPath, 1,
       PyDoc_STR("() -> None")},
      {"CGContextMoveToPoint", (PyCFunction)CGContextRefObj_CGContextMoveToPoint, 1,
       PyDoc_STR("(float x, float y) -> None")},
      {"CGContextAddLineToPoint", (PyCFunction)CGContextRefObj_CGContextAddLineToPoint, 1,
       PyDoc_STR("(float x, float y) -> None")},
      {"CGContextAddCurveToPoint", (PyCFunction)CGContextRefObj_CGContextAddCurveToPoint, 1,
       PyDoc_STR("(float cp1x, float cp1y, float cp2x, float cp2y, float x, float y) -> None")},
      {"CGContextAddQuadCurveToPoint", (PyCFunction)CGContextRefObj_CGContextAddQuadCurveToPoint, 1,
       PyDoc_STR("(float cpx, float cpy, float x, float y) -> None")},
      {"CGContextClosePath", (PyCFunction)CGContextRefObj_CGContextClosePath, 1,
       PyDoc_STR("() -> None")},
      {"CGContextAddRect", (PyCFunction)CGContextRefObj_CGContextAddRect, 1,
       PyDoc_STR("(CGRect rect) -> None")},
      {"CGContextAddArc", (PyCFunction)CGContextRefObj_CGContextAddArc, 1,
       PyDoc_STR("(float x, float y, float radius, float startAngle, float endAngle, int clockwise) -> None")},
      {"CGContextAddArcToPoint", (PyCFunction)CGContextRefObj_CGContextAddArcToPoint, 1,
       PyDoc_STR("(float x1, float y1, float x2, float y2, float radius) -> None")},
      {"CGContextIsPathEmpty", (PyCFunction)CGContextRefObj_CGContextIsPathEmpty, 1,
       PyDoc_STR("() -> (int _rv)")},
      {"CGContextGetPathCurrentPoint", (PyCFunction)CGContextRefObj_CGContextGetPathCurrentPoint, 1,
       PyDoc_STR("() -> (CGPoint _rv)")},
      {"CGContextGetPathBoundingBox", (PyCFunction)CGContextRefObj_CGContextGetPathBoundingBox, 1,
       PyDoc_STR("() -> (CGRect _rv)")},
      {"CGContextDrawPath", (PyCFunction)CGContextRefObj_CGContextDrawPath, 1,
       PyDoc_STR("(int mode) -> None")},
      {"CGContextFillPath", (PyCFunction)CGContextRefObj_CGContextFillPath, 1,
       PyDoc_STR("() -> None")},
      {"CGContextEOFillPath", (PyCFunction)CGContextRefObj_CGContextEOFillPath, 1,
       PyDoc_STR("() -> None")},
      {"CGContextStrokePath", (PyCFunction)CGContextRefObj_CGContextStrokePath, 1,
       PyDoc_STR("() -> None")},
      {"CGContextFillRect", (PyCFunction)CGContextRefObj_CGContextFillRect, 1,
       PyDoc_STR("(CGRect rect) -> None")},
      {"CGContextStrokeRect", (PyCFunction)CGContextRefObj_CGContextStrokeRect, 1,
       PyDoc_STR("(CGRect rect) -> None")},
      {"CGContextStrokeRectWithWidth", (PyCFunction)CGContextRefObj_CGContextStrokeRectWithWidth, 1,
       PyDoc_STR("(CGRect rect, float width) -> None")},
      {"CGContextClearRect", (PyCFunction)CGContextRefObj_CGContextClearRect, 1,
       PyDoc_STR("(CGRect rect) -> None")},
      {"CGContextClip", (PyCFunction)CGContextRefObj_CGContextClip, 1,
       PyDoc_STR("() -> None")},
      {"CGContextEOClip", (PyCFunction)CGContextRefObj_CGContextEOClip, 1,
       PyDoc_STR("() -> None")},
      {"CGContextClipToRect", (PyCFunction)CGContextRefObj_CGContextClipToRect, 1,
       PyDoc_STR("(CGRect rect) -> None")},
      {"CGContextSetGrayFillColor", (PyCFunction)CGContextRefObj_CGContextSetGrayFillColor, 1,
       PyDoc_STR("(float gray, float alpha) -> None")},
      {"CGContextSetGrayStrokeColor", (PyCFunction)CGContextRefObj_CGContextSetGrayStrokeColor, 1,
       PyDoc_STR("(float gray, float alpha) -> None")},
      {"CGContextSetRGBFillColor", (PyCFunction)CGContextRefObj_CGContextSetRGBFillColor, 1,
       PyDoc_STR("(float red, float green, float blue, float alpha) -> None")},
      {"CGContextSetRGBStrokeColor", (PyCFunction)CGContextRefObj_CGContextSetRGBStrokeColor, 1,
       PyDoc_STR("(float red, float green, float blue, float alpha) -> None")},
      {"CGContextSetCMYKFillColor", (PyCFunction)CGContextRefObj_CGContextSetCMYKFillColor, 1,
       PyDoc_STR("(float cyan, float magenta, float yellow, float black, float alpha) -> None")},
      {"CGContextSetCMYKStrokeColor", (PyCFunction)CGContextRefObj_CGContextSetCMYKStrokeColor, 1,
       PyDoc_STR("(float cyan, float magenta, float yellow, float black, float alpha) -> None")},
      {"CGContextGetInterpolationQuality", (PyCFunction)CGContextRefObj_CGContextGetInterpolationQuality, 1,
       PyDoc_STR("() -> (int _rv)")},
      {"CGContextSetInterpolationQuality", (PyCFunction)CGContextRefObj_CGContextSetInterpolationQuality, 1,
       PyDoc_STR("(int quality) -> None")},
      {"CGContextSetCharacterSpacing", (PyCFunction)CGContextRefObj_CGContextSetCharacterSpacing, 1,
       PyDoc_STR("(float spacing) -> None")},
      {"CGContextSetTextPosition", (PyCFunction)CGContextRefObj_CGContextSetTextPosition, 1,
       PyDoc_STR("(float x, float y) -> None")},
      {"CGContextGetTextPosition", (PyCFunction)CGContextRefObj_CGContextGetTextPosition, 1,
       PyDoc_STR("() -> (CGPoint _rv)")},
      {"CGContextSetTextMatrix", (PyCFunction)CGContextRefObj_CGContextSetTextMatrix, 1,
       PyDoc_STR("(CGAffineTransform transform) -> None")},
      {"CGContextGetTextMatrix", (PyCFunction)CGContextRefObj_CGContextGetTextMatrix, 1,
       PyDoc_STR("() -> (CGAffineTransform _rv)")},
      {"CGContextSetTextDrawingMode", (PyCFunction)CGContextRefObj_CGContextSetTextDrawingMode, 1,
       PyDoc_STR("(int mode) -> None")},
      {"CGContextSetFontSize", (PyCFunction)CGContextRefObj_CGContextSetFontSize, 1,
       PyDoc_STR("(float size) -> None")},
      {"CGContextSelectFont", (PyCFunction)CGContextRefObj_CGContextSelectFont, 1,
       PyDoc_STR("(char * name, float size, int textEncoding) -> None")},
      {"CGContextShowText", (PyCFunction)CGContextRefObj_CGContextShowText, 1,
       PyDoc_STR("(Buffer cstring) -> None")},
      {"CGContextShowTextAtPoint", (PyCFunction)CGContextRefObj_CGContextShowTextAtPoint, 1,
       PyDoc_STR("(float x, float y, Buffer cstring) -> None")},
      {"CGContextEndPage", (PyCFunction)CGContextRefObj_CGContextEndPage, 1,
       PyDoc_STR("() -> None")},
      {"CGContextFlush", (PyCFunction)CGContextRefObj_CGContextFlush, 1,
       PyDoc_STR("() -> None")},
      {"CGContextSynchronize", (PyCFunction)CGContextRefObj_CGContextSynchronize, 1,
       PyDoc_STR("() -> None")},
      {"CGContextSetShouldAntialias", (PyCFunction)CGContextRefObj_CGContextSetShouldAntialias, 1,
       PyDoc_STR("(int shouldAntialias) -> None")},
  #ifndef __LP64__
      {"SyncCGContextOriginWithPort", (PyCFunction)CGContextRefObj_SyncCGContextOriginWithPort, 1,
       PyDoc_STR("(CGrafPtr port) -> None")},
      {"ClipCGContextToRegion", (PyCFunction)CGContextRefObj_ClipCGContextToRegion, 1,
       PyDoc_STR("(Rect portRect, RgnHandle region) -> None")},
  #endif
      {NULL, NULL, 0}
  };
  
  #define CGContextRefObj_getsetlist NULL
  
  
  #define CGContextRefObj_compare NULL
  
  #define CGContextRefObj_repr NULL
  
  #define CGContextRefObj_hash NULL
  #define CGContextRefObj_tp_init 0
  
  #define CGContextRefObj_tp_alloc PyType_GenericAlloc
  
  static PyObject *CGContextRefObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
  {
      PyObject *_self;
      CGContextRef itself;
      char *kw[] = {"itself", 0};
  
      if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CGContextRefObj_Convert, &itself)) return NULL;
      if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
      ((CGContextRefObject *)_self)->ob_itself = itself;
      return _self;
  }
  
  #define CGContextRefObj_tp_free PyObject_Del
  
  
  PyTypeObject CGContextRef_Type = {
      PyObject_HEAD_INIT(NULL)
      0, /*ob_size*/
      "_CG.CGContextRef", /*tp_name*/
      sizeof(CGContextRefObject), /*tp_basicsize*/
      0, /*tp_itemsize*/
      /* methods */
      (destructor) CGContextRefObj_dealloc, /*tp_dealloc*/
      0, /*tp_print*/
      (getattrfunc)0, /*tp_getattr*/
      (setattrfunc)0, /*tp_setattr*/
      (cmpfunc) CGContextRefObj_compare, /*tp_compare*/
      (reprfunc) CGContextRefObj_repr, /*tp_repr*/
      (PyNumberMethods *)0, /* tp_as_number */
      (PySequenceMethods *)0, /* tp_as_sequence */
      (PyMappingMethods *)0, /* tp_as_mapping */
      (hashfunc) CGContextRefObj_hash, /*tp_hash*/
      0, /*tp_call*/
      0, /*tp_str*/
      PyObject_GenericGetAttr, /*tp_getattro*/
      PyObject_GenericSetAttr, /*tp_setattro */
      0, /*tp_as_buffer*/
      Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
      0, /*tp_doc*/
      0, /*tp_traverse*/
      0, /*tp_clear*/
      0, /*tp_richcompare*/
      0, /*tp_weaklistoffset*/
      0, /*tp_iter*/
      0, /*tp_iternext*/
      CGContextRefObj_methods, /* tp_methods */
      0, /*tp_members*/
      CGContextRefObj_getsetlist, /*tp_getset*/
      0, /*tp_base*/
      0, /*tp_dict*/
      0, /*tp_descr_get*/
      0, /*tp_descr_set*/
      0, /*tp_dictoffset*/
      CGContextRefObj_tp_init, /* tp_init */
      CGContextRefObj_tp_alloc, /* tp_alloc */
      CGContextRefObj_tp_new, /* tp_new */
      CGContextRefObj_tp_free, /* tp_free */
  };
  
  /* ------------------ End object type CGContextRef ------------------ */
  
  
  #ifndef __LP64__
  static PyObject *CG_CreateCGContextForPort(PyObject *_self, PyObject *_args)
  {
      PyObject *_res = NULL;
      GrafPtr port;
      CGContextRef ctx;
      OSStatus _err;
  
      if (!PyArg_ParseTuple(_args, "O&", GrafObj_Convert, &port))
          return NULL;
  
      _err = CreateCGContextForPort(port, &ctx);
      if (_err != noErr)
          if (_err != noErr) return PyMac_Error(_err);
      _res = Py_BuildValue("O&", CGContextRefObj_New, ctx);
      return _res;
  
  }
  #endif
  
  static PyMethodDef CG_methods[] = {
  #ifndef __LP64__
      {"CreateCGContextForPort", (PyCFunction)CG_CreateCGContextForPort, 1,
       PyDoc_STR("(CGrafPtr) -> CGContextRef")},
  #endif
      {NULL, NULL, 0}
  };
  
  
  
  
  void init_CG(void)
  {
      PyObject *m;
      PyObject *d;
  
  
  
  
      m = Py_InitModule("_CG", CG_methods);
      d = PyModule_GetDict(m);
      CG_Error = PyMac_GetOSErrException();
      if (CG_Error == NULL ||
          PyDict_SetItemString(d, "Error", CG_Error) != 0)
          return;
      CGContextRef_Type.ob_type = &PyType_Type;
      if (PyType_Ready(&CGContextRef_Type) < 0) return;
      Py_INCREF(&CGContextRef_Type);
      PyModule_AddObject(m, "CGContextRef", (PyObject *)&CGContextRef_Type);
      /* Backward-compatible name */
      Py_INCREF(&CGContextRef_Type);
      PyModule_AddObject(m, "CGContextRefType", (PyObject *)&CGContextRef_Type);
  }
  
  /* ========================= End module _CG ========================= */
  
  