1 

     2 /* =========================== Module _Qd =========================== */

     3 

     4 #include "Python.h"

     5 

     6 

     7 #ifndef __LP64__

     8 

     9 #include "pymactoolbox.h"

    10 

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

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

    13         PyErr_SetString(PyExc_NotImplementedError, \

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

    15         return NULL; \

    16     }} while(0)

    17 

    18 

    19 #include <Carbon/Carbon.h>

    20 

    21 #ifdef USE_TOOLBOX_OBJECT_GLUE

    22 extern PyObject *_GrafObj_New(GrafPtr);

    23 extern int _GrafObj_Convert(PyObject *, GrafPtr *);

    24 extern PyObject *_BMObj_New(BitMapPtr);

    25 extern int _BMObj_Convert(PyObject *, BitMapPtr *);

    26 extern PyObject *_QdRGB_New(RGBColorPtr);

    27 extern int _QdRGB_Convert(PyObject *, RGBColorPtr);

    28 

    29 #define GrafObj_New _GrafObj_New

    30 #define GrafObj_Convert _GrafObj_Convert

    31 #define BMObj_New _BMObj_New

    32 #define BMObj_Convert _BMObj_Convert

    33 #define QdRGB_New _QdRGB_New

    34 #define QdRGB_Convert _QdRGB_Convert

    35 #endif

    36 

    37 static PyObject *BMObj_NewCopied(BitMapPtr);

    38 

    39 /*

    40 ** Parse/generate RGB records

    41 */

    42 PyObject *QdRGB_New(RGBColorPtr itself)

    43 {

    44 

    45         return Py_BuildValue("lll", (long)itself->red, (long)itself->green, (long)itself->blue);

    46 }

    47 

    48 int QdRGB_Convert(PyObject *v, RGBColorPtr p_itself)

    49 {

    50         long red, green, blue;

    51 

    52         if( !PyArg_ParseTuple(v, "lll", &red, &green, &blue) )

    53                 return 0;

    54         p_itself->red = (unsigned short)red;

    55         p_itself->green = (unsigned short)green;

    56         p_itself->blue = (unsigned short)blue;

    57         return 1;

    58 }

    59 

    60 /*

    61 ** Generate FontInfo records

    62 */

    63 static

    64 PyObject *QdFI_New(FontInfo *itself)

    65 {

    66 

    67         return Py_BuildValue("hhhh", itself->ascent, itself->descent,

    68                         itself->widMax, itself->leading);

    69 }

    70 

    71 static PyObject *Qd_Error;

    72 

    73 /* ---------------------- Object type GrafPort ---------------------- */

    74 

    75 PyTypeObject GrafPort_Type;

    76 

    77 #define GrafObj_Check(x) ((x)->ob_type == &GrafPort_Type || PyObject_TypeCheck((x), &GrafPort_Type))

    78 

    79 typedef struct GrafPortObject {

    80 	PyObject_HEAD

    81 	GrafPtr ob_itself;

    82 } GrafPortObject;

    83 

    84 PyObject *GrafObj_New(GrafPtr itself)

    85 {

    86 	GrafPortObject *it;

    87 	if (itself == NULL) return PyMac_Error(resNotFound);

    88 	it = PyObject_NEW(GrafPortObject, &GrafPort_Type);

    89 	if (it == NULL) return NULL;

    90 	it->ob_itself = itself;

    91 	return (PyObject *)it;

    92 }

    93 

    94 int GrafObj_Convert(PyObject *v, GrafPtr *p_itself)

    95 {

    96 #if 1

    97 	{

    98 		WindowRef win;

    99 		if (WinObj_Convert(v, &win) && v) {

   100 			*p_itself = (GrafPtr)GetWindowPort(win);

   101 			return 1;

   102 		}

   103 		PyErr_Clear();

   104 	}

   105 #else

   106 	if (DlgObj_Check(v)) {

   107 		DialogRef dlg = (DialogRef)((GrafPortObject *)v)->ob_itself;

   108 		*p_itself = (GrafPtr)GetWindowPort(GetDialogWindow(dlg));

   109 		return 1;

   110 	}

   111 	if (WinObj_Check(v)) {

   112 		WindowRef win = (WindowRef)((GrafPortObject *)v)->ob_itself;

   113 		*p_itself = (GrafPtr)GetWindowPort(win);

   114 		return 1;

   115 	}

   116 #endif

   117 	if (!GrafObj_Check(v))

   118 	{

   119 		PyErr_SetString(PyExc_TypeError, "GrafPort required");

   120 		return 0;

   121 	}

   122 	*p_itself = ((GrafPortObject *)v)->ob_itself;

   123 	return 1;

   124 }

   125 

   126 static void GrafObj_dealloc(GrafPortObject *self)

   127 {

   128 	/* Cleanup of self->ob_itself goes here */

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

   130 }

   131 

   132 static PyObject *GrafObj_MacSetPort(GrafPortObject *_self, PyObject *_args)

   133 {

   134 	PyObject *_res = NULL;

   135 #ifndef MacSetPort

   136 	PyMac_PRECHECK(MacSetPort);

   137 #endif

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

   139 		return NULL;

   140 	MacSetPort(_self->ob_itself);

   141 	Py_INCREF(Py_None);

   142 	_res = Py_None;

   143 	return _res;

   144 }

   145 

   146 static PyObject *GrafObj_QDSwapPort(GrafPortObject *_self, PyObject *_args)

   147 {

   148 	PyObject *_res = NULL;

   149 	Boolean _rv;

   150 	CGrafPtr outOldPort;

   151 #ifndef QDSwapPort

   152 	PyMac_PRECHECK(QDSwapPort);

   153 #endif

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

   155 		return NULL;

   156 	_rv = QDSwapPort(_self->ob_itself,

   157 	                 &outOldPort);

   158 	_res = Py_BuildValue("bO&",

   159 	                     _rv,

   160 	                     GrafObj_New, outOldPort);

   161 	return _res;

   162 }

   163 

   164 static PyObject *GrafObj_IsValidPort(GrafPortObject *_self, PyObject *_args)

   165 {

   166 	PyObject *_res = NULL;

   167 	Boolean _rv;

   168 #ifndef IsValidPort

   169 	PyMac_PRECHECK(IsValidPort);

   170 #endif

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

   172 		return NULL;

   173 	_rv = IsValidPort(_self->ob_itself);

   174 	_res = Py_BuildValue("b",

   175 	                     _rv);

   176 	return _res;

   177 }

   178 

   179 static PyObject *GrafObj_GetPortPixMap(GrafPortObject *_self, PyObject *_args)

   180 {

   181 	PyObject *_res = NULL;

   182 	PixMapHandle _rv;

   183 #ifndef GetPortPixMap

   184 	PyMac_PRECHECK(GetPortPixMap);

   185 #endif

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

   187 		return NULL;

   188 	_rv = GetPortPixMap(_self->ob_itself);

   189 	_res = Py_BuildValue("O&",

   190 	                     ResObj_New, _rv);

   191 	return _res;

   192 }

   193 

   194 static PyObject *GrafObj_GetPortBitMapForCopyBits(GrafPortObject *_self, PyObject *_args)

   195 {

   196 	PyObject *_res = NULL;

   197 	const BitMap * _rv;

   198 #ifndef GetPortBitMapForCopyBits

   199 	PyMac_PRECHECK(GetPortBitMapForCopyBits);

   200 #endif

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

   202 		return NULL;

   203 	_rv = GetPortBitMapForCopyBits(_self->ob_itself);

   204 	_res = Py_BuildValue("O&",

   205 	                     BMObj_New, _rv);

   206 	return _res;

   207 }

   208 

   209 static PyObject *GrafObj_GetPortBounds(GrafPortObject *_self, PyObject *_args)

   210 {

   211 	PyObject *_res = NULL;

   212 	Rect rect;

   213 #ifndef GetPortBounds

   214 	PyMac_PRECHECK(GetPortBounds);

   215 #endif

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

   217 		return NULL;

   218 	GetPortBounds(_self->ob_itself,

   219 	              &rect);

   220 	_res = Py_BuildValue("O&",

   221 	                     PyMac_BuildRect, &rect);

   222 	return _res;

   223 }

   224 

   225 static PyObject *GrafObj_GetPortForeColor(GrafPortObject *_self, PyObject *_args)

   226 {

   227 	PyObject *_res = NULL;

   228 	RGBColor foreColor;

   229 #ifndef GetPortForeColor

   230 	PyMac_PRECHECK(GetPortForeColor);

   231 #endif

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

   233 		return NULL;

   234 	GetPortForeColor(_self->ob_itself,

   235 	                 &foreColor);

   236 	_res = Py_BuildValue("O&",

   237 	                     QdRGB_New, &foreColor);

   238 	return _res;

   239 }

   240 

   241 static PyObject *GrafObj_GetPortBackColor(GrafPortObject *_self, PyObject *_args)

   242 {

   243 	PyObject *_res = NULL;

   244 	RGBColor backColor;

   245 #ifndef GetPortBackColor

   246 	PyMac_PRECHECK(GetPortBackColor);

   247 #endif

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

   249 		return NULL;

   250 	GetPortBackColor(_self->ob_itself,

   251 	                 &backColor);

   252 	_res = Py_BuildValue("O&",

   253 	                     QdRGB_New, &backColor);

   254 	return _res;

   255 }

   256 

   257 static PyObject *GrafObj_GetPortOpColor(GrafPortObject *_self, PyObject *_args)

   258 {

   259 	PyObject *_res = NULL;

   260 	RGBColor opColor;

   261 #ifndef GetPortOpColor

   262 	PyMac_PRECHECK(GetPortOpColor);

   263 #endif

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

   265 		return NULL;

   266 	GetPortOpColor(_self->ob_itself,

   267 	               &opColor);

   268 	_res = Py_BuildValue("O&",

   269 	                     QdRGB_New, &opColor);

   270 	return _res;

   271 }

   272 

   273 static PyObject *GrafObj_GetPortHiliteColor(GrafPortObject *_self, PyObject *_args)

   274 {

   275 	PyObject *_res = NULL;

   276 	RGBColor hiliteColor;

   277 #ifndef GetPortHiliteColor

   278 	PyMac_PRECHECK(GetPortHiliteColor);

   279 #endif

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

   281 		return NULL;

   282 	GetPortHiliteColor(_self->ob_itself,

   283 	                   &hiliteColor);

   284 	_res = Py_BuildValue("O&",

   285 	                     QdRGB_New, &hiliteColor);

   286 	return _res;

   287 }

   288 

   289 static PyObject *GrafObj_GetPortTextFont(GrafPortObject *_self, PyObject *_args)

   290 {

   291 	PyObject *_res = NULL;

   292 	short _rv;

   293 #ifndef GetPortTextFont

   294 	PyMac_PRECHECK(GetPortTextFont);

   295 #endif

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

   297 		return NULL;

   298 	_rv = GetPortTextFont(_self->ob_itself);

   299 	_res = Py_BuildValue("h",

   300 	                     _rv);

   301 	return _res;

   302 }

   303 

   304 static PyObject *GrafObj_GetPortTextFace(GrafPortObject *_self, PyObject *_args)

   305 {

   306 	PyObject *_res = NULL;

   307 	Style _rv;

   308 #ifndef GetPortTextFace

   309 	PyMac_PRECHECK(GetPortTextFace);

   310 #endif

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

   312 		return NULL;

   313 	_rv = GetPortTextFace(_self->ob_itself);

   314 	_res = Py_BuildValue("b",

   315 	                     _rv);

   316 	return _res;

   317 }

   318 

   319 static PyObject *GrafObj_GetPortTextMode(GrafPortObject *_self, PyObject *_args)

   320 {

   321 	PyObject *_res = NULL;

   322 	short _rv;

   323 #ifndef GetPortTextMode

   324 	PyMac_PRECHECK(GetPortTextMode);

   325 #endif

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

   327 		return NULL;

   328 	_rv = GetPortTextMode(_self->ob_itself);

   329 	_res = Py_BuildValue("h",

   330 	                     _rv);

   331 	return _res;

   332 }

   333 

   334 static PyObject *GrafObj_GetPortTextSize(GrafPortObject *_self, PyObject *_args)

   335 {

   336 	PyObject *_res = NULL;

   337 	short _rv;

   338 #ifndef GetPortTextSize

   339 	PyMac_PRECHECK(GetPortTextSize);

   340 #endif

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

   342 		return NULL;

   343 	_rv = GetPortTextSize(_self->ob_itself);

   344 	_res = Py_BuildValue("h",

   345 	                     _rv);

   346 	return _res;

   347 }

   348 

   349 static PyObject *GrafObj_GetPortChExtra(GrafPortObject *_self, PyObject *_args)

   350 {

   351 	PyObject *_res = NULL;

   352 	short _rv;

   353 #ifndef GetPortChExtra

   354 	PyMac_PRECHECK(GetPortChExtra);

   355 #endif

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

   357 		return NULL;

   358 	_rv = GetPortChExtra(_self->ob_itself);

   359 	_res = Py_BuildValue("h",

   360 	                     _rv);

   361 	return _res;

   362 }

   363 

   364 static PyObject *GrafObj_GetPortFracHPenLocation(GrafPortObject *_self, PyObject *_args)

   365 {

   366 	PyObject *_res = NULL;

   367 	short _rv;

   368 #ifndef GetPortFracHPenLocation

   369 	PyMac_PRECHECK(GetPortFracHPenLocation);

   370 #endif

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

   372 		return NULL;

   373 	_rv = GetPortFracHPenLocation(_self->ob_itself);

   374 	_res = Py_BuildValue("h",

   375 	                     _rv);

   376 	return _res;

   377 }

   378 

   379 static PyObject *GrafObj_GetPortSpExtra(GrafPortObject *_self, PyObject *_args)

   380 {

   381 	PyObject *_res = NULL;

   382 	Fixed _rv;

   383 #ifndef GetPortSpExtra

   384 	PyMac_PRECHECK(GetPortSpExtra);

   385 #endif

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

   387 		return NULL;

   388 	_rv = GetPortSpExtra(_self->ob_itself);

   389 	_res = Py_BuildValue("O&",

   390 	                     PyMac_BuildFixed, _rv);

   391 	return _res;

   392 }

   393 

   394 static PyObject *GrafObj_GetPortPenVisibility(GrafPortObject *_self, PyObject *_args)

   395 {

   396 	PyObject *_res = NULL;

   397 	short _rv;

   398 #ifndef GetPortPenVisibility

   399 	PyMac_PRECHECK(GetPortPenVisibility);

   400 #endif

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

   402 		return NULL;

   403 	_rv = GetPortPenVisibility(_self->ob_itself);

   404 	_res = Py_BuildValue("h",

   405 	                     _rv);

   406 	return _res;

   407 }

   408 

   409 static PyObject *GrafObj_GetPortVisibleRegion(GrafPortObject *_self, PyObject *_args)

   410 {

   411 	PyObject *_res = NULL;

   412 	RgnHandle _rv;

   413 	RgnHandle visRgn;

   414 #ifndef GetPortVisibleRegion

   415 	PyMac_PRECHECK(GetPortVisibleRegion);

   416 #endif

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

   418 	                      ResObj_Convert, &visRgn))

   419 		return NULL;

   420 	_rv = GetPortVisibleRegion(_self->ob_itself,

   421 	                           visRgn);

   422 	_res = Py_BuildValue("O&",

   423 	                     ResObj_New, _rv);

   424 	return _res;

   425 }

   426 

   427 static PyObject *GrafObj_GetPortClipRegion(GrafPortObject *_self, PyObject *_args)

   428 {

   429 	PyObject *_res = NULL;

   430 	RgnHandle _rv;

   431 	RgnHandle clipRgn;

   432 #ifndef GetPortClipRegion

   433 	PyMac_PRECHECK(GetPortClipRegion);

   434 #endif

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

   436 	                      ResObj_Convert, &clipRgn))

   437 		return NULL;

   438 	_rv = GetPortClipRegion(_self->ob_itself,

   439 	                        clipRgn);

   440 	_res = Py_BuildValue("O&",

   441 	                     ResObj_New, _rv);

   442 	return _res;

   443 }

   444 

   445 static PyObject *GrafObj_GetPortBackPixPat(GrafPortObject *_self, PyObject *_args)

   446 {

   447 	PyObject *_res = NULL;

   448 	PixPatHandle _rv;

   449 	PixPatHandle backPattern;

   450 #ifndef GetPortBackPixPat

   451 	PyMac_PRECHECK(GetPortBackPixPat);

   452 #endif

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

   454 	                      ResObj_Convert, &backPattern))

   455 		return NULL;

   456 	_rv = GetPortBackPixPat(_self->ob_itself,

   457 	                        backPattern);

   458 	_res = Py_BuildValue("O&",

   459 	                     ResObj_New, _rv);

   460 	return _res;

   461 }

   462 

   463 static PyObject *GrafObj_GetPortPenPixPat(GrafPortObject *_self, PyObject *_args)

   464 {

   465 	PyObject *_res = NULL;

   466 	PixPatHandle _rv;

   467 	PixPatHandle penPattern;

   468 #ifndef GetPortPenPixPat

   469 	PyMac_PRECHECK(GetPortPenPixPat);

   470 #endif

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

   472 	                      ResObj_Convert, &penPattern))

   473 		return NULL;

   474 	_rv = GetPortPenPixPat(_self->ob_itself,

   475 	                       penPattern);

   476 	_res = Py_BuildValue("O&",

   477 	                     ResObj_New, _rv);

   478 	return _res;

   479 }

   480 

   481 static PyObject *GrafObj_GetPortFillPixPat(GrafPortObject *_self, PyObject *_args)

   482 {

   483 	PyObject *_res = NULL;

   484 	PixPatHandle _rv;

   485 	PixPatHandle fillPattern;

   486 #ifndef GetPortFillPixPat

   487 	PyMac_PRECHECK(GetPortFillPixPat);

   488 #endif

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

   490 	                      ResObj_Convert, &fillPattern))

   491 		return NULL;

   492 	_rv = GetPortFillPixPat(_self->ob_itself,

   493 	                        fillPattern);

   494 	_res = Py_BuildValue("O&",

   495 	                     ResObj_New, _rv);

   496 	return _res;

   497 }

   498 

   499 static PyObject *GrafObj_GetPortPenSize(GrafPortObject *_self, PyObject *_args)

   500 {

   501 	PyObject *_res = NULL;

   502 	Point penSize;

   503 #ifndef GetPortPenSize

   504 	PyMac_PRECHECK(GetPortPenSize);

   505 #endif

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

   507 	                      PyMac_GetPoint, &penSize))

   508 		return NULL;

   509 	GetPortPenSize(_self->ob_itself,

   510 	               &penSize);

   511 	_res = Py_BuildValue("O&",

   512 	                     PyMac_BuildPoint, penSize);

   513 	return _res;

   514 }

   515 

   516 static PyObject *GrafObj_GetPortPenMode(GrafPortObject *_self, PyObject *_args)

   517 {

   518 	PyObject *_res = NULL;

   519 	SInt32 _rv;

   520 #ifndef GetPortPenMode

   521 	PyMac_PRECHECK(GetPortPenMode);

   522 #endif

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

   524 		return NULL;

   525 	_rv = GetPortPenMode(_self->ob_itself);

   526 	_res = Py_BuildValue("l",

   527 	                     _rv);

   528 	return _res;

   529 }

   530 

   531 static PyObject *GrafObj_GetPortPenLocation(GrafPortObject *_self, PyObject *_args)

   532 {

   533 	PyObject *_res = NULL;

   534 	Point penLocation;

   535 #ifndef GetPortPenLocation

   536 	PyMac_PRECHECK(GetPortPenLocation);

   537 #endif

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

   539 	                      PyMac_GetPoint, &penLocation))

   540 		return NULL;

   541 	GetPortPenLocation(_self->ob_itself,

   542 	                   &penLocation);

   543 	_res = Py_BuildValue("O&",

   544 	                     PyMac_BuildPoint, penLocation);

   545 	return _res;

   546 }

   547 

   548 static PyObject *GrafObj_IsPortRegionBeingDefined(GrafPortObject *_self, PyObject *_args)

   549 {

   550 	PyObject *_res = NULL;

   551 	Boolean _rv;

   552 #ifndef IsPortRegionBeingDefined

   553 	PyMac_PRECHECK(IsPortRegionBeingDefined);

   554 #endif

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

   556 		return NULL;

   557 	_rv = IsPortRegionBeingDefined(_self->ob_itself);

   558 	_res = Py_BuildValue("b",

   559 	                     _rv);

   560 	return _res;

   561 }

   562 

   563 static PyObject *GrafObj_IsPortPictureBeingDefined(GrafPortObject *_self, PyObject *_args)

   564 {

   565 	PyObject *_res = NULL;

   566 	Boolean _rv;

   567 #ifndef IsPortPictureBeingDefined

   568 	PyMac_PRECHECK(IsPortPictureBeingDefined);

   569 #endif

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

   571 		return NULL;

   572 	_rv = IsPortPictureBeingDefined(_self->ob_itself);

   573 	_res = Py_BuildValue("b",

   574 	                     _rv);

   575 	return _res;

   576 }

   577 

   578 static PyObject *GrafObj_IsPortPolyBeingDefined(GrafPortObject *_self, PyObject *_args)

   579 {

   580 	PyObject *_res = NULL;

   581 	Boolean _rv;

   582 #ifndef IsPortPolyBeingDefined

   583 	PyMac_PRECHECK(IsPortPolyBeingDefined);

   584 #endif

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

   586 		return NULL;

   587 	_rv = IsPortPolyBeingDefined(_self->ob_itself);

   588 	_res = Py_BuildValue("b",

   589 	                     _rv);

   590 	return _res;

   591 }

   592 

   593 static PyObject *GrafObj_IsPortOffscreen(GrafPortObject *_self, PyObject *_args)

   594 {

   595 	PyObject *_res = NULL;

   596 	Boolean _rv;

   597 #ifndef IsPortOffscreen

   598 	PyMac_PRECHECK(IsPortOffscreen);

   599 #endif

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

   601 		return NULL;

   602 	_rv = IsPortOffscreen(_self->ob_itself);

   603 	_res = Py_BuildValue("b",

   604 	                     _rv);

   605 	return _res;

   606 }

   607 

   608 static PyObject *GrafObj_IsPortColor(GrafPortObject *_self, PyObject *_args)

   609 {

   610 	PyObject *_res = NULL;

   611 	Boolean _rv;

   612 #ifndef IsPortColor

   613 	PyMac_PRECHECK(IsPortColor);

   614 #endif

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

   616 		return NULL;

   617 	_rv = IsPortColor(_self->ob_itself);

   618 	_res = Py_BuildValue("b",

   619 	                     _rv);

   620 	return _res;

   621 }

   622 

   623 static PyObject *GrafObj_IsPortVisibleRegionEmpty(GrafPortObject *_self, PyObject *_args)

   624 {

   625 	PyObject *_res = NULL;

   626 	Boolean _rv;

   627 #ifndef IsPortVisibleRegionEmpty

   628 	PyMac_PRECHECK(IsPortVisibleRegionEmpty);

   629 #endif

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

   631 		return NULL;

   632 	_rv = IsPortVisibleRegionEmpty(_self->ob_itself);

   633 	_res = Py_BuildValue("b",

   634 	                     _rv);

   635 	return _res;

   636 }

   637 

   638 static PyObject *GrafObj_IsPortClipRegionEmpty(GrafPortObject *_self, PyObject *_args)

   639 {

   640 	PyObject *_res = NULL;

   641 	Boolean _rv;

   642 #ifndef IsPortClipRegionEmpty

   643 	PyMac_PRECHECK(IsPortClipRegionEmpty);

   644 #endif

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

   646 		return NULL;

   647 	_rv = IsPortClipRegionEmpty(_self->ob_itself);

   648 	_res = Py_BuildValue("b",

   649 	                     _rv);

   650 	return _res;

   651 }

   652 

   653 static PyObject *GrafObj_SectRegionWithPortClipRegion(GrafPortObject *_self, PyObject *_args)

   654 {

   655 	PyObject *_res = NULL;

   656 	RgnHandle ioRegion;

   657 #ifndef SectRegionWithPortClipRegion

   658 	PyMac_PRECHECK(SectRegionWithPortClipRegion);

   659 #endif

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

   661 	                      ResObj_Convert, &ioRegion))

   662 		return NULL;

   663 	SectRegionWithPortClipRegion(_self->ob_itself,

   664 	                             ioRegion);

   665 	Py_INCREF(Py_None);

   666 	_res = Py_None;

   667 	return _res;

   668 }

   669 

   670 static PyObject *GrafObj_SectRegionWithPortVisibleRegion(GrafPortObject *_self, PyObject *_args)

   671 {

   672 	PyObject *_res = NULL;

   673 	RgnHandle ioRegion;

   674 #ifndef SectRegionWithPortVisibleRegion

   675 	PyMac_PRECHECK(SectRegionWithPortVisibleRegion);

   676 #endif

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

   678 	                      ResObj_Convert, &ioRegion))

   679 		return NULL;

   680 	SectRegionWithPortVisibleRegion(_self->ob_itself,

   681 	                                ioRegion);

   682 	Py_INCREF(Py_None);

   683 	_res = Py_None;

   684 	return _res;

   685 }

   686 

   687 static PyObject *GrafObj_SwapPortPicSaveHandle(GrafPortObject *_self, PyObject *_args)

   688 {

   689 	PyObject *_res = NULL;

   690 	Handle _rv;

   691 	Handle inPicSaveHdl;

   692 #ifndef SwapPortPicSaveHandle

   693 	PyMac_PRECHECK(SwapPortPicSaveHandle);

   694 #endif

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

   696 	                      ResObj_Convert, &inPicSaveHdl))

   697 		return NULL;

   698 	_rv = SwapPortPicSaveHandle(_self->ob_itself,

   699 	                            inPicSaveHdl);

   700 	_res = Py_BuildValue("O&",

   701 	                     ResObj_New, _rv);

   702 	return _res;

   703 }

   704 

   705 static PyObject *GrafObj_SwapPortPolySaveHandle(GrafPortObject *_self, PyObject *_args)

   706 {

   707 	PyObject *_res = NULL;

   708 	Handle _rv;

   709 	Handle inPolySaveHdl;

   710 #ifndef SwapPortPolySaveHandle

   711 	PyMac_PRECHECK(SwapPortPolySaveHandle);

   712 #endif

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

   714 	                      ResObj_Convert, &inPolySaveHdl))

   715 		return NULL;

   716 	_rv = SwapPortPolySaveHandle(_self->ob_itself,

   717 	                             inPolySaveHdl);

   718 	_res = Py_BuildValue("O&",

   719 	                     ResObj_New, _rv);

   720 	return _res;

   721 }

   722 

   723 static PyObject *GrafObj_SwapPortRegionSaveHandle(GrafPortObject *_self, PyObject *_args)

   724 {

   725 	PyObject *_res = NULL;

   726 	Handle _rv;

   727 	Handle inRegionSaveHdl;

   728 #ifndef SwapPortRegionSaveHandle

   729 	PyMac_PRECHECK(SwapPortRegionSaveHandle);

   730 #endif

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

   732 	                      ResObj_Convert, &inRegionSaveHdl))

   733 		return NULL;

   734 	_rv = SwapPortRegionSaveHandle(_self->ob_itself,

   735 	                               inRegionSaveHdl);

   736 	_res = Py_BuildValue("O&",

   737 	                     ResObj_New, _rv);

   738 	return _res;

   739 }

   740 

   741 static PyObject *GrafObj_SetPortBounds(GrafPortObject *_self, PyObject *_args)

   742 {

   743 	PyObject *_res = NULL;

   744 	Rect rect;

   745 #ifndef SetPortBounds

   746 	PyMac_PRECHECK(SetPortBounds);

   747 #endif

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

   749 	                      PyMac_GetRect, &rect))

   750 		return NULL;

   751 	SetPortBounds(_self->ob_itself,

   752 	              &rect);

   753 	Py_INCREF(Py_None);

   754 	_res = Py_None;

   755 	return _res;

   756 }

   757 

   758 static PyObject *GrafObj_SetPortOpColor(GrafPortObject *_self, PyObject *_args)

   759 {

   760 	PyObject *_res = NULL;

   761 	RGBColor opColor;

   762 #ifndef SetPortOpColor

   763 	PyMac_PRECHECK(SetPortOpColor);

   764 #endif

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

   766 	                      QdRGB_Convert, &opColor))

   767 		return NULL;

   768 	SetPortOpColor(_self->ob_itself,

   769 	               &opColor);

   770 	Py_INCREF(Py_None);

   771 	_res = Py_None;

   772 	return _res;

   773 }

   774 

   775 static PyObject *GrafObj_SetPortTextFont(GrafPortObject *_self, PyObject *_args)

   776 {

   777 	PyObject *_res = NULL;

   778 	short txFont;

   779 #ifndef SetPortTextFont

   780 	PyMac_PRECHECK(SetPortTextFont);

   781 #endif

   782 	if (!PyArg_ParseTuple(_args, "h",

   783 	                      &txFont))

   784 		return NULL;

   785 	SetPortTextFont(_self->ob_itself,

   786 	                txFont);

   787 	Py_INCREF(Py_None);

   788 	_res = Py_None;

   789 	return _res;

   790 }

   791 

   792 static PyObject *GrafObj_SetPortTextSize(GrafPortObject *_self, PyObject *_args)

   793 {

   794 	PyObject *_res = NULL;

   795 	short txSize;

   796 #ifndef SetPortTextSize

   797 	PyMac_PRECHECK(SetPortTextSize);

   798 #endif

   799 	if (!PyArg_ParseTuple(_args, "h",

   800 	                      &txSize))

   801 		return NULL;

   802 	SetPortTextSize(_self->ob_itself,

   803 	                txSize);

   804 	Py_INCREF(Py_None);

   805 	_res = Py_None;

   806 	return _res;

   807 }

   808 

   809 static PyObject *GrafObj_SetPortTextFace(GrafPortObject *_self, PyObject *_args)

   810 {

   811 	PyObject *_res = NULL;

   812 	StyleParameter face;

   813 #ifndef SetPortTextFace

   814 	PyMac_PRECHECK(SetPortTextFace);

   815 #endif

   816 	if (!PyArg_ParseTuple(_args, "h",

   817 	                      &face))

   818 		return NULL;

   819 	SetPortTextFace(_self->ob_itself,

   820 	                face);

   821 	Py_INCREF(Py_None);

   822 	_res = Py_None;

   823 	return _res;

   824 }

   825 

   826 static PyObject *GrafObj_SetPortTextMode(GrafPortObject *_self, PyObject *_args)

   827 {

   828 	PyObject *_res = NULL;

   829 	short mode;

   830 #ifndef SetPortTextMode

   831 	PyMac_PRECHECK(SetPortTextMode);

   832 #endif

   833 	if (!PyArg_ParseTuple(_args, "h",

   834 	                      &mode))

   835 		return NULL;

   836 	SetPortTextMode(_self->ob_itself,

   837 	                mode);

   838 	Py_INCREF(Py_None);

   839 	_res = Py_None;

   840 	return _res;

   841 }

   842 

   843 static PyObject *GrafObj_SetPortVisibleRegion(GrafPortObject *_self, PyObject *_args)

   844 {

   845 	PyObject *_res = NULL;

   846 	RgnHandle visRgn;

   847 #ifndef SetPortVisibleRegion

   848 	PyMac_PRECHECK(SetPortVisibleRegion);

   849 #endif

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

   851 	                      ResObj_Convert, &visRgn))

   852 		return NULL;

   853 	SetPortVisibleRegion(_self->ob_itself,

   854 	                     visRgn);

   855 	Py_INCREF(Py_None);

   856 	_res = Py_None;

   857 	return _res;

   858 }

   859 

   860 static PyObject *GrafObj_SetPortClipRegion(GrafPortObject *_self, PyObject *_args)

   861 {

   862 	PyObject *_res = NULL;

   863 	RgnHandle clipRgn;

   864 #ifndef SetPortClipRegion

   865 	PyMac_PRECHECK(SetPortClipRegion);

   866 #endif

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

   868 	                      ResObj_Convert, &clipRgn))

   869 		return NULL;

   870 	SetPortClipRegion(_self->ob_itself,

   871 	                  clipRgn);

   872 	Py_INCREF(Py_None);

   873 	_res = Py_None;

   874 	return _res;

   875 }

   876 

   877 static PyObject *GrafObj_SetPortPenPixPat(GrafPortObject *_self, PyObject *_args)

   878 {

   879 	PyObject *_res = NULL;

   880 	PixPatHandle penPattern;

   881 #ifndef SetPortPenPixPat

   882 	PyMac_PRECHECK(SetPortPenPixPat);

   883 #endif

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

   885 	                      ResObj_Convert, &penPattern))

   886 		return NULL;

   887 	SetPortPenPixPat(_self->ob_itself,

   888 	                 penPattern);

   889 	Py_INCREF(Py_None);

   890 	_res = Py_None;

   891 	return _res;

   892 }

   893 

   894 static PyObject *GrafObj_SetPortFillPixPat(GrafPortObject *_self, PyObject *_args)

   895 {

   896 	PyObject *_res = NULL;

   897 	PixPatHandle penPattern;

   898 #ifndef SetPortFillPixPat

   899 	PyMac_PRECHECK(SetPortFillPixPat);

   900 #endif

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

   902 	                      ResObj_Convert, &penPattern))

   903 		return NULL;

   904 	SetPortFillPixPat(_self->ob_itself,

   905 	                  penPattern);

   906 	Py_INCREF(Py_None);

   907 	_res = Py_None;

   908 	return _res;

   909 }

   910 

   911 static PyObject *GrafObj_SetPortBackPixPat(GrafPortObject *_self, PyObject *_args)

   912 {

   913 	PyObject *_res = NULL;

   914 	PixPatHandle backPattern;

   915 #ifndef SetPortBackPixPat

   916 	PyMac_PRECHECK(SetPortBackPixPat);

   917 #endif

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

   919 	                      ResObj_Convert, &backPattern))

   920 		return NULL;

   921 	SetPortBackPixPat(_self->ob_itself,

   922 	                  backPattern);

   923 	Py_INCREF(Py_None);

   924 	_res = Py_None;

   925 	return _res;

   926 }

   927 

   928 static PyObject *GrafObj_SetPortPenSize(GrafPortObject *_self, PyObject *_args)

   929 {

   930 	PyObject *_res = NULL;

   931 	Point penSize;

   932 #ifndef SetPortPenSize

   933 	PyMac_PRECHECK(SetPortPenSize);

   934 #endif

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

   936 	                      PyMac_GetPoint, &penSize))

   937 		return NULL;

   938 	SetPortPenSize(_self->ob_itself,

   939 	               penSize);

   940 	Py_INCREF(Py_None);

   941 	_res = Py_None;

   942 	return _res;

   943 }

   944 

   945 static PyObject *GrafObj_SetPortPenMode(GrafPortObject *_self, PyObject *_args)

   946 {

   947 	PyObject *_res = NULL;

   948 	SInt32 penMode;

   949 #ifndef SetPortPenMode

   950 	PyMac_PRECHECK(SetPortPenMode);

   951 #endif

   952 	if (!PyArg_ParseTuple(_args, "l",

   953 	                      &penMode))

   954 		return NULL;

   955 	SetPortPenMode(_self->ob_itself,

   956 	               penMode);

   957 	Py_INCREF(Py_None);

   958 	_res = Py_None;

   959 	return _res;

   960 }

   961 

   962 static PyObject *GrafObj_SetPortFracHPenLocation(GrafPortObject *_self, PyObject *_args)

   963 {

   964 	PyObject *_res = NULL;

   965 	short pnLocHFrac;

   966 #ifndef SetPortFracHPenLocation

   967 	PyMac_PRECHECK(SetPortFracHPenLocation);

   968 #endif

   969 	if (!PyArg_ParseTuple(_args, "h",

   970 	                      &pnLocHFrac))

   971 		return NULL;

   972 	SetPortFracHPenLocation(_self->ob_itself,

   973 	                        pnLocHFrac);

   974 	Py_INCREF(Py_None);

   975 	_res = Py_None;

   976 	return _res;

   977 }

   978 

   979 static PyObject *GrafObj_DisposePort(GrafPortObject *_self, PyObject *_args)

   980 {

   981 	PyObject *_res = NULL;

   982 #ifndef DisposePort

   983 	PyMac_PRECHECK(DisposePort);

   984 #endif

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

   986 		return NULL;

   987 	DisposePort(_self->ob_itself);

   988 	Py_INCREF(Py_None);

   989 	_res = Py_None;

   990 	return _res;

   991 }

   992 

   993 static PyObject *GrafObj_QDLocalToGlobalPoint(GrafPortObject *_self, PyObject *_args)

   994 {

   995 	PyObject *_res = NULL;

   996 	Point point;

   997 #ifndef QDLocalToGlobalPoint

   998 	PyMac_PRECHECK(QDLocalToGlobalPoint);

   999 #endif

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

  1001 	                      PyMac_GetPoint, &point))

  1002 		return NULL;

  1003 	QDLocalToGlobalPoint(_self->ob_itself,

  1004 	                     &point);

  1005 	_res = Py_BuildValue("O&",

  1006 	                     PyMac_BuildPoint, point);

  1007 	return _res;

  1008 }

  1009 

  1010 static PyObject *GrafObj_QDGlobalToLocalPoint(GrafPortObject *_self, PyObject *_args)

  1011 {

  1012 	PyObject *_res = NULL;

  1013 	Point point;

  1014 #ifndef QDGlobalToLocalPoint

  1015 	PyMac_PRECHECK(QDGlobalToLocalPoint);

  1016 #endif

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

  1018 	                      PyMac_GetPoint, &point))

  1019 		return NULL;

  1020 	QDGlobalToLocalPoint(_self->ob_itself,

  1021 	                     &point);

  1022 	_res = Py_BuildValue("O&",

  1023 	                     PyMac_BuildPoint, point);

  1024 	return _res;

  1025 }

  1026 

  1027 static PyObject *GrafObj_QDLocalToGlobalRect(GrafPortObject *_self, PyObject *_args)

  1028 {

  1029 	PyObject *_res = NULL;

  1030 	Rect bounds;

  1031 #ifndef QDLocalToGlobalRect

  1032 	PyMac_PRECHECK(QDLocalToGlobalRect);

  1033 #endif

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

  1035 		return NULL;

  1036 	QDLocalToGlobalRect(_self->ob_itself,

  1037 	                    &bounds);

  1038 	_res = Py_BuildValue("O&",

  1039 	                     PyMac_BuildRect, &bounds);

  1040 	return _res;

  1041 }

  1042 

  1043 static PyObject *GrafObj_QDGlobalToLocalRect(GrafPortObject *_self, PyObject *_args)

  1044 {

  1045 	PyObject *_res = NULL;

  1046 	Rect bounds;

  1047 #ifndef QDGlobalToLocalRect

  1048 	PyMac_PRECHECK(QDGlobalToLocalRect);

  1049 #endif

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

  1051 		return NULL;

  1052 	QDGlobalToLocalRect(_self->ob_itself,

  1053 	                    &bounds);

  1054 	_res = Py_BuildValue("O&",

  1055 	                     PyMac_BuildRect, &bounds);

  1056 	return _res;

  1057 }

  1058 

  1059 static PyObject *GrafObj_QDLocalToGlobalRegion(GrafPortObject *_self, PyObject *_args)

  1060 {

  1061 	PyObject *_res = NULL;

  1062 	RgnHandle _rv;

  1063 	RgnHandle region;

  1064 #ifndef QDLocalToGlobalRegion

  1065 	PyMac_PRECHECK(QDLocalToGlobalRegion);

  1066 #endif

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

  1068 	                      ResObj_Convert, &region))

  1069 		return NULL;

  1070 	_rv = QDLocalToGlobalRegion(_self->ob_itself,

  1071 	                            region);

  1072 	_res = Py_BuildValue("O&",

  1073 	                     ResObj_New, _rv);

  1074 	return _res;

  1075 }

  1076 

  1077 static PyObject *GrafObj_QDGlobalToLocalRegion(GrafPortObject *_self, PyObject *_args)

  1078 {

  1079 	PyObject *_res = NULL;

  1080 	RgnHandle _rv;

  1081 	RgnHandle region;

  1082 #ifndef QDGlobalToLocalRegion

  1083 	PyMac_PRECHECK(QDGlobalToLocalRegion);

  1084 #endif

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

  1086 	                      ResObj_Convert, &region))

  1087 		return NULL;

  1088 	_rv = QDGlobalToLocalRegion(_self->ob_itself,

  1089 	                            region);

  1090 	_res = Py_BuildValue("O&",

  1091 	                     ResObj_New, _rv);

  1092 	return _res;

  1093 }

  1094 

  1095 static PyObject *GrafObj_QDIsPortBuffered(GrafPortObject *_self, PyObject *_args)

  1096 {

  1097 	PyObject *_res = NULL;

  1098 	Boolean _rv;

  1099 #ifndef QDIsPortBuffered

  1100 	PyMac_PRECHECK(QDIsPortBuffered);

  1101 #endif

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

  1103 		return NULL;

  1104 	_rv = QDIsPortBuffered(_self->ob_itself);

  1105 	_res = Py_BuildValue("b",

  1106 	                     _rv);

  1107 	return _res;

  1108 }

  1109 

  1110 static PyObject *GrafObj_QDIsPortBufferDirty(GrafPortObject *_self, PyObject *_args)

  1111 {

  1112 	PyObject *_res = NULL;

  1113 	Boolean _rv;

  1114 #ifndef QDIsPortBufferDirty

  1115 	PyMac_PRECHECK(QDIsPortBufferDirty);

  1116 #endif

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

  1118 		return NULL;

  1119 	_rv = QDIsPortBufferDirty(_self->ob_itself);

  1120 	_res = Py_BuildValue("b",

  1121 	                     _rv);

  1122 	return _res;

  1123 }

  1124 

  1125 static PyObject *GrafObj_QDFlushPortBuffer(GrafPortObject *_self, PyObject *_args)

  1126 {

  1127 	PyObject *_res = NULL;

  1128 	RgnHandle region;

  1129 #ifndef QDFlushPortBuffer

  1130 	PyMac_PRECHECK(QDFlushPortBuffer);

  1131 #endif

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

  1133 	                      OptResObj_Convert, &region))

  1134 		return NULL;

  1135 	QDFlushPortBuffer(_self->ob_itself,